Embed reflect-example and fixture shaders with the GLSL quasiquoters

The reflect examples and the vulkan-utils-spirv test suite consumed
committed .spv files produced by out-of-band build-shaders.sh scripts,
which broke CI on a fresh checkout (the .spv were gitignored, and two
fixtures had no GLSL source at all). Shaders are now compiled at build
time by the vulkan-utils GLSL quasiquoters and reflected from the
embedded bytes; the scripts, shader files and file-embed dependency are
gone.

vulkan-utils-spirv gains the missing Bytes variants for the stage TH:
reflectStageSigBytes and reflectPipelineLayoutSigBytes, mirroring
reflectShaderTypesBytes.

Each example is restructured around per-pipeline modules whose
<Pipeline>.Shader submodule holds the quasiquoted SPIR-V (satisfying the
TH stage restriction) and whose pipeline module reflects it and builds
the pipeline; Main does the setup and Render the headless frame:

  * compute-reflect:   Main, Render, Julia(.Shader)
  * mesh-reflect:      Main, Render, Mesh(.Shader)
  * texture-reflect:   Main, Render, Tri(.Shader), Cube(.Shader)
  * pathtrace-reflect: Main, Render, Scene, Pathtracer(.Shader)

The pathtracer and bda shaders use compileShaderQ with a vulkan1.2
target (buffer_reference), wide.comp with vulkan1.1 (Int64). The
sourceless julia.comp and tri.vert fixtures are reconstructed from the
test suite's layout assertions, which pin them exactly.

All four examples render correctly (mesh/texture self-checks pass) and
the 75 vulkan-utils-spirv tests pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dpwiz

examples/compute-reflect/Julia.hs

@@ -0,0 +1,101 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DeriveAnyClass #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE DerivingVia #-}
+{-# LANGUAGE OverloadedLists #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeFamilies #-}
+
+{-| Julia-set compute pipeline, its interface reflected from 'Julia.Shader.code':
+
+  * 'reflectShaderTypesBytes' generates the 'Params' push-constant record (with
+    a gl-block std430 'Storable');
+  * 'singleDescriptorSetLayoutInfo' builds the descriptor set layout for the
+    output SSBO;
+  * 'pushConstantRanges' builds the pipeline layout's push-constant range; and
+  * 'allocateSpecializationInfo' builds the pipeline's specialization info
+    (@maxIterations@, @escapeRadius@) from the reflected constant ids.
+
+Compare with the @compute@ example, which hand-writes all of this.
+-}
+module Julia
+  ( Params (..)
+  , Pipeline (..)
+  , allocatePipeline
+  , workgroup
+  ) where
+
+import Control.Monad.Trans.Resource (ResourceT, allocate)
+import qualified Data.Vector as V
+import Data.Word (Word32)
+import qualified Geomancy
+import Graphics.Gl.Block (Std430 (..))
+import Vulkan.CStruct.Extends (SomeStruct (..))
+import qualified Vulkan.Core10 as PipelineLayoutCreateInfo (PipelineLayoutCreateInfo (..))
+import qualified Vulkan.Core10 as Vk
+import Vulkan.Utils.Shader (shaderModuleStage)
+import Vulkan.Utils.SpirV.Descriptors (pushConstantRanges, singleDescriptorSetLayoutInfo)
+import Vulkan.Utils.SpirV.Reflect (reflectBytes)
+import Vulkan.Utils.SpirV.Specialization (allocateSpecializationInfo)
+import Vulkan.Utils.SpirV.TH (reflectShaderTypesBytes)
+import Vulkan.Zero (zero)
+
+import qualified Julia.Shader as Shader
+
+-- Generate the @Params@ push-constant record (and its std430 'Storable') from
+-- the same SPIR-V the runtime loads.
+reflectShaderTypesBytes Shader.code
+
+-- | Workgroup size on each axis (matches @local_size_x/y@ in the shader).
+workgroup :: Int
+workgroup = 16
+
+data Pipeline = Pipeline
+  { pipeline :: Vk.Pipeline
+  , pipelineLayout :: Vk.PipelineLayout
+  , descriptorSetLayout :: Vk.DescriptorSetLayout
+  }
+
+{- | The pipeline, specialized to the given iteration cap and escape radius.
+
+Descriptor set layout, push-constant range and specialization info all come
+from reflecting 'Shader.code'.
+-}
+allocatePipeline :: Vk.Device -> Word32 -> Float -> ResourceT IO Pipeline
+allocatePipeline dev maxIterations escapeRadius = do
+  -- Reflect the embedded module once; reuse it for the descriptor set layout,
+  -- the push-constant range and the specialization info.
+  reflected <- reflectBytes Shader.code
+
+  setLayoutInfo <- either fail pure (singleDescriptorSetLayoutInfo reflected)
+  (_, descriptorSetLayout) <- Vk.withDescriptorSetLayout dev setLayoutInfo Nothing allocate
+
+  mSpec <- allocateSpecializationInfo reflected (maxIterations, escapeRadius)
+  (_, shader) <- shaderModuleStage dev Vk.SHADER_STAGE_COMPUTE_BIT mSpec Shader.code
+  (_, pipelineLayout) <-
+    Vk.withPipelineLayout
+      dev
+      zero
+        { PipelineLayoutCreateInfo.setLayouts = [descriptorSetLayout]
+        , PipelineLayoutCreateInfo.pushConstantRanges =
+            V.fromList (pushConstantRanges reflected)
+        }
+      Nothing
+      allocate
+  let
+    pipelineCreateInfo :: Vk.ComputePipelineCreateInfo '[]
+    pipelineCreateInfo =
+      zero
+        { Vk.layout = pipelineLayout
+        , Vk.stage = shader
+        , Vk.basePipelineHandle = zero
+        }
+  (_, (_, [computePipeline])) <-
+    Vk.withComputePipelines dev zero [SomeStruct pipelineCreateInfo] Nothing allocate
+  pure
+    Pipeline
+      { pipeline = computePipeline
+      , pipelineLayout = pipelineLayout
+      , descriptorSetLayout = descriptorSetLayout
+      }

examples/compute-reflect/Julia/Shader.hs

@@ -0,0 +1,75 @@
+{-# LANGUAGE QuasiQuotes #-}
+
+{-| The Julia-set compute shader, compiled to SPIR-V at build time.
+
+Its interface is reflected by vulkan-utils-spirv in the "Julia" module:
+the @Params@ push-constant block, the output SSBO's descriptor set layout,
+and the specialization constants.
+-}
+module Julia.Shader
+  ( code
+  ) where
+
+import Data.ByteString (ByteString)
+import Vulkan.Utils.ShaderQQ.GLSL.Glslang (comp)
+
+code :: ByteString
+code =
+  [comp|
+    #version 450
+    #extension GL_ARB_separate_shader_objects : enable
+
+    layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
+
+    // Specialized at pipeline-creation time (see Vulkan.Utils.SpirV.Specialization).
+    layout(constant_id = 0) const uint  maxIterations = 1000u;
+    layout(constant_id = 1) const float escapeRadius = 2.0;
+
+    // Fields are ordered by non-increasing alignment (vec2/uvec2 = 8) so gl-block's
+    // Generic std430 layout matches the shader; see the guardrail in
+    // Vulkan.Utils.SpirV.Block.
+    layout(push_constant, std430) uniform Params {
+      vec2  center;      // c in the Julia iteration
+      uvec2 resolution;  // output size in pixels
+    } params;
+
+    layout(set = 0, binding = 0, std430) buffer OutputBuffer {
+      vec4 pixels[];
+    };
+
+    // From https://iquilezles.org/articles/palettes/
+    vec3 palette(float t) {
+      const vec3 a = vec3(0.5);
+      const vec3 b = vec3(0.5);
+      const vec3 c = vec3(1.0);
+      const vec3 d = vec3(0.0, 0.10, 0.20);
+      return a + b * cos(6.28318530718 * (c * t + d));
+    }
+
+    void main() {
+      uvec2 gid = gl_GlobalInvocationID.xy;
+      if (gid.x >= params.resolution.x || gid.y >= params.resolution.y) {
+        return;
+      }
+
+      vec2 uv =
+        ( vec2(gid) / vec2(params.resolution) * 2.0 - 1.0 ) * escapeRadius;
+
+      vec2 z = uv;
+      int i = 0;
+      for (; i < int(maxIterations); ++i) {
+        vec2 z2 = vec2(z.x * z.x - z.y * z.y, 2.0 * z.x * z.y);
+        z = z2 + params.center;
+        if (dot(z, z) > escapeRadius * escapeRadius) {
+          break;
+        }
+      }
+
+      uint idx = gid.y * params.resolution.x + gid.x;
+      if (i == int(maxIterations)) {
+        pixels[idx] = vec4(0.0, 0.0, 0.0, 1.0);
+      } else {
+        pixels[idx] = vec4(palette(float(i) / float(maxIterations)), 1.0);
+      }
+    }
+  |]