vulkan: use specialization constants

build/vulkan.rs

@@ -1,7 +1,7 @@
 use {
     crate::open,
-    anyhow::{bail, Context},
+    anyhow::{anyhow, bail, Context},
-    shaderc::CompileOptions,
+    shaderc::{CompileOptions, ResolvedInclude},
     std::{io::Write, path::Path},
 };
 
@@ -12,21 +12,17 @@ pub fn main() -> anyhow::Result<()> {
     compile_simple("fill.frag")?;
     compile_simple("fill.vert")?;
     compile_simple("tex.vert")?;
-    compile_tex_frag("tex.frag.spv", false, false)?;
+    compile_tex_frag("tex.frag.spv", false)?;
-    compile_tex_frag("tex.frag.mult+opaque.spv", false, true)?;
+    compile_tex_frag("tex.frag.mult.spv", true)?;
-    compile_tex_frag("tex.frag.mult+alpha.spv", true, true)?;
     Ok(())
 }
 
-fn compile_tex_frag(out: &str, alpha: bool, alpha_multiplier: bool) -> anyhow::Result<()> {
+fn compile_tex_frag(out: &str, alpha_multiplier: bool) -> anyhow::Result<()> {
     let mut opts = CompileOptions::new().unwrap();
-    if alpha {
-        opts.add_macro_definition("ALPHA", None);
-    }
     if alpha_multiplier {
         opts.add_macro_definition("ALPHA_MULTIPLIER", None);
     }
-    compile_shader("tex.frag", out, Some(&opts)).with_context(|| out.to_string())?;
+    compile_shader("tex.frag", out, Some(opts)).with_context(|| out.to_string())?;
     Ok(())
 }
 
@@ -34,7 +30,15 @@ fn compile_simple(name: &str) -> anyhow::Result<()> {
     compile_shader(name, &format!("{name}.spv"), None).with_context(|| name.to_string())
 }
 
-fn compile_shader(name: &str, out: &str, options: Option<&CompileOptions>) -> anyhow::Result<()> {
+fn compile_shader(name: &str, out: &str, options: Option<CompileOptions>) -> anyhow::Result<()> {
+    let read = |path: &str| std::fs::read_to_string(format!("{}/{}", ROOT, path));
+    let mut options = options.unwrap_or_else(|| CompileOptions::new().unwrap());
+    options.set_include_callback(|name, _, _, _| {
+        Ok(ResolvedInclude {
+            resolved_name: name.to_string(),
+            content: read(name).map_err(|e| anyhow!(e).to_string())?,
+        })
+    });
     let stage = match Path::new(name)
         .extension()
         .and_then(|e| e.to_str())
@@ -44,10 +48,10 @@ fn compile_shader(name: &str, out: &str, options: Option<&CompileOptions>) -> an
         "vert" => shaderc::ShaderKind::Vertex,
         n => bail!("Unknown shader stage {}", n),
     };
-    let src = std::fs::read_to_string(format!("{}/{}", ROOT, name))?;
+    let src = read(name)?;
     let compiler = shaderc::Compiler::new().unwrap();
     let binary = compiler
-        .compile_into_spirv(&src, stage, name, "main", options)
+        .compile_into_spirv(&src, stage, name, "main", Some(&options))
         .unwrap();
     let mut file = open(out)?;
     file.write_all(binary.as_binary_u8())?;

src/gfx_apis/vulkan/pipeline.rs

@@ -18,6 +18,7 @@ use {
             PipelineRenderingCreateInfo, PipelineShaderStageCreateInfo,
             PipelineVertexInputStateCreateInfo, PipelineViewportStateCreateInfo, PolygonMode,
             PrimitiveTopology, PushConstantRange, SampleCountFlags, ShaderStageFlags,
+            SpecializationInfo, SpecializationMapEntry,
         },
     },
     std::{rc::Rc, slice},
@@ -36,7 +37,8 @@ pub(super) struct PipelineCreateInfo {
     pub(super) format: vk::Format,
     pub(super) vert: Rc<VulkanShader>,
     pub(super) frag: Rc<VulkanShader>,
-    pub(super) alpha: bool,
+    pub(super) blend: bool,
+    pub(super) src_has_alpha: bool,
     pub(super) frag_descriptor_set_layout: Option<Rc<VulkanDescriptorSetLayout>>,
 }
 
@@ -89,6 +91,15 @@ impl VulkanDevice {
         };
         let destroy_layout =
             OnDrop(|| unsafe { self.device.destroy_pipeline_layout(pipeline_layout, None) });
+        let mut frag_spec_data = ArrayVec::<_, 4>::new();
+        frag_spec_data.extend((info.src_has_alpha as u32).to_ne_bytes());
+        let frag_spec_entries = [SpecializationMapEntry::default()
+            .constant_id(0)
+            .size(4)
+            .offset(0)];
+        let frag_spec = SpecializationInfo::default()
+            .map_entries(&frag_spec_entries)
+            .data(&frag_spec_data);
         let pipeline = {
             let stages = [
                 PipelineShaderStageCreateInfo::default()
@@ -98,6 +109,7 @@ impl VulkanDevice {
                 PipelineShaderStageCreateInfo::default()
                     .stage(ShaderStageFlags::FRAGMENT)
                     .module(info.frag.module)
+                    .specialization_info(&frag_spec)
                     .name(c"main"),
             ];
             let input_assembly_state = PipelineInputAssemblyStateCreateInfo::default()
@@ -113,7 +125,7 @@ impl VulkanDevice {
                 .rasterization_samples(SampleCountFlags::TYPE_1);
             let mut blending = PipelineColorBlendAttachmentState::default()
                 .color_write_mask(ColorComponentFlags::RGBA);
-            if info.alpha {
+            if info.blend {
                 blending = blending
                     .blend_enable(true)
                     .src_color_blend_factor(BlendFactor::ONE)

src/gfx_apis/vulkan/renderer.rs

@@ -18,8 +18,8 @@ use {
             semaphore::VulkanSemaphore,
             shaders::{
                 FillFragPushConstants, FillVertPushConstants, TexFragPushConstants,
-                TexVertPushConstants, VulkanShader, FILL_FRAG, FILL_VERT, TEX_FRAG,
+                TexVertPushConstants, VulkanShader, FILL_FRAG, FILL_VERT, TEX_FRAG, TEX_FRAG_MULT,
-                TEX_FRAG_MULT_ALPHA, TEX_FRAG_MULT_OPAQUE, TEX_VERT,
+                TEX_VERT,
             },
             VulkanError,
         },
@@ -74,8 +74,7 @@ pub struct VulkanRenderer {
     pub(super) fill_frag_shader: Rc<VulkanShader>,
     pub(super) tex_vert_shader: Rc<VulkanShader>,
     pub(super) tex_frag_shader: Rc<VulkanShader>,
-    pub(super) tex_frag_mult_opaque_shader: Rc<VulkanShader>,
+    pub(super) tex_frag_mult_shader: Rc<VulkanShader>,
-    pub(super) tex_frag_mult_alpha_shader: Rc<VulkanShader>,
     pub(super) tex_descriptor_set_layout: Rc<VulkanDescriptorSetLayout>,
     pub(super) defunct: Cell<bool>,
     pub(super) pending_cpu_jobs: CopyHashMap<u64, PendingJob>,
@@ -160,8 +159,7 @@ impl VulkanDevice {
         let tex_descriptor_set_layout = self.create_descriptor_set_layout(&sampler)?;
         let tex_vert_shader = self.create_shader(TEX_VERT)?;
         let tex_frag_shader = self.create_shader(TEX_FRAG)?;
-        let tex_frag_mult_opaque_shader = self.create_shader(TEX_FRAG_MULT_OPAQUE)?;
+        let tex_frag_mult_shader = self.create_shader(TEX_FRAG_MULT)?;
-        let tex_frag_mult_alpha_shader = self.create_shader(TEX_FRAG_MULT_ALPHA)?;
         let gfx_command_buffers = self.create_command_pool(self.graphics_queue_idx)?;
         let transfer_command_buffers = self
             .distinct_transfer_queue_family_idx
@@ -219,8 +217,7 @@ impl VulkanDevice {
             fill_frag_shader,
             tex_vert_shader,
             tex_frag_shader,
-            tex_frag_mult_opaque_shader,
+            tex_frag_mult_shader,
-            tex_frag_mult_alpha_shader,
             tex_descriptor_set_layout,
             defunct: Cell::new(false),
             pending_cpu_jobs: Default::default(),
@@ -246,34 +243,37 @@ impl VulkanRenderer {
                     format,
                     vert: self.fill_vert_shader.clone(),
                     frag: self.fill_frag_shader.clone(),
-                    alpha: true,
+                    blend: true,
+                    src_has_alpha: true,
                     frag_descriptor_set_layout: None,
                 },
             )?;
-        let create_tex_pipeline = |alpha| {
+        let create_tex_pipeline = |src_has_alpha| {
             self.device
                 .create_pipeline::<TexVertPushConstants, ()>(PipelineCreateInfo {
                     format,
                     vert: self.tex_vert_shader.clone(),
                     frag: self.tex_frag_shader.clone(),
-                    alpha,
+                    blend: src_has_alpha,
+                    src_has_alpha,
                     frag_descriptor_set_layout: Some(self.tex_descriptor_set_layout.clone()),
                 })
         };
-        let create_tex_mult_pipeline = |frag: &Rc<VulkanShader>| {
+        let create_tex_mult_pipeline = |src_has_alpha: bool| {
             self.device
                 .create_pipeline::<TexVertPushConstants, TexFragPushConstants>(PipelineCreateInfo {
                     format,
                     vert: self.tex_vert_shader.clone(),
-                    frag: frag.clone(),
+                    frag: self.tex_frag_mult_shader.clone(),
-                    alpha: true,
+                    blend: true,
+                    src_has_alpha,
                     frag_descriptor_set_layout: Some(self.tex_descriptor_set_layout.clone()),
                 })
         };
         let tex_opaque = create_tex_pipeline(false)?;
         let tex_alpha = create_tex_pipeline(true)?;
-        let tex_mult_opaque = create_tex_mult_pipeline(&self.tex_frag_mult_opaque_shader)?;
+        let tex_mult_opaque = create_tex_mult_pipeline(false)?;
-        let tex_mult_alpha = create_tex_mult_pipeline(&self.tex_frag_mult_alpha_shader)?;
+        let tex_mult_alpha = create_tex_mult_pipeline(true)?;
         let pipelines = Rc::new(VulkanFormatPipelines {
             fill,
             tex: static_map! {

src/gfx_apis/vulkan/shaders.rs

@@ -9,10 +9,7 @@ pub const FILL_VERT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/fill.vert
 pub const FILL_FRAG: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/fill.frag.spv"));
 pub const TEX_VERT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/tex.vert.spv"));
 pub const TEX_FRAG: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/tex.frag.spv"));
-pub const TEX_FRAG_MULT_OPAQUE: &[u8] =
+pub const TEX_FRAG_MULT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/tex.frag.mult.spv"));
-    include_bytes!(concat!(env!("OUT_DIR"), "/tex.frag.mult+opaque.spv"));
-pub const TEX_FRAG_MULT_ALPHA: &[u8] =
-    include_bytes!(concat!(env!("OUT_DIR"), "/tex.frag.mult+alpha.spv"));
 
 pub struct VulkanShader {
     pub(super) device: Rc<VulkanDevice>,

src/gfx_apis/vulkan/shaders/fill.frag

@@ -1,5 +1,7 @@
 #version 450
 
+#include "frag_spec_const.glsl"
+
 layout(push_constant, std430) uniform Data {
 	layout(offset = 32) vec4 color;
 } data;

src/gfx_apis/vulkan/shaders/frag_spec_const.glsl

@@ -0,0 +1 @@
+layout(constant_id = 0) const bool src_has_alpha = false;

src/gfx_apis/vulkan/shaders/tex.frag

@@ -1,5 +1,7 @@
 #version 450
 
+#include "frag_spec_const.glsl"
+
 #ifdef ALPHA_MULTIPLIER
 layout(push_constant, std430) uniform Data {
 	layout(offset = 64) float mul;
@@ -11,10 +13,11 @@ layout(location = 0) out vec4 out_color;
 
 void main() {
 #ifdef ALPHA_MULTIPLIER
-#ifdef ALPHA
+	if (src_has_alpha) {
-	out_color = textureLod(tex, tex_pos, 0) * data.mul;
+		out_color = textureLod(tex, tex_pos, 0) * data.mul;
-#endif // !ALPHA
+	} else {
-	out_color = vec4(textureLod(tex, tex_pos, 0).rgb * data.mul, data.mul);
+		out_color = vec4(textureLod(tex, tex_pos, 0).rgb * data.mul, data.mul);
+	}
 #else // !ALPHA_MULTIPLIER
 	out_color = textureLod(tex, tex_pos, 0);
 #endif