adjust build action to use SpirvBuilder

Author: Firestar99

Cargo.lock

@@ -13,7 +13,7 @@ exclude = [
 resolver = "2"
 
 [workspace.dependencies]
-spirv-builder = { git = "https://github.com/Rust-GPU/rust-gpu.git", rev = "744c844eb761edf23bcd379b5271d128128d7dfa", default-features = false }
+spirv-builder = { git = "https://github.com/Rust-GPU/rust-gpu.git", rev = "436846c9084920f6ed6840370ec9d694d13ded32", default-features = false }
 anyhow = "1.0.94"
 clap = { version = "4.5.37", features = ["derive"] }
 chrono = { version = "0.4.38", default-features = false, features = ["std"] }

Cargo.toml

@@ -2,12 +2,12 @@
 #![allow(clippy::unwrap_used, reason = "this is basically a test")]
 //! `cargo gpu build`, analogous to `cargo build`
 
-use anyhow::Context as _;
-use std::io::Write as _;
-
 use crate::args::BuildArgs;
-use crate::linkage::{Linkage, ShaderModule};
+use crate::linkage::Linkage;
 use crate::{install::Install, target_spec_dir};
+use anyhow::Context as _;
+use spirv_builder::ModuleResult;
+use std::io::Write as _;
 
 /// `cargo build` subcommands
 #[derive(clap::Parser, Debug, serde::Deserialize, serde::Serialize)]
@@ -25,7 +25,16 @@ impl Build {
     /// Entrypoint
     #[expect(clippy::too_many_lines, reason = "It's not too confusing")]
     pub fn run(&mut self) -> anyhow::Result<()> {
-        self.install.run()?;
+        let (rustc_codegen_spirv_location, toolchain_channel) = self.install.run()?;
+
+        let builder = &mut self.build_args.spirv_builder;
+        builder.rustc_codegen_spirv_location = Some(rustc_codegen_spirv_location);
+        builder.toolchain_overwrite = Some(toolchain_channel);
+        builder.path_to_crate = Some(self.install.spirv_install.shader_crate.clone());
+        builder.path_to_target_spec = Some(target_spec_dir()?.join(format!(
+            "{}.json",
+            builder.target.as_ref().context("expect target to be set")?
+        )));
 
         // Ensure the shader output dir exists
         log::debug!(
@@ -47,96 +56,58 @@ impl Build {
             std::env::current_dir()?.display()
         );
 
-        if !self.build_args.watch {
-            self.build_args.spirv_builder.target = Some(
-                target_spec_dir()?
-                    .join(format!(
-                        "{}.json",
-                        self.build_args
-                            .spirv_builder
-                            .target
-                            .as_ref()
-                            .context("expect target to be set")?
-                    ))
-                    .display()
-                    .to_string(),
-            );
-        }
-
-        let args_as_json = serde_json::json!({
-            "install": self.install.spirv_install,
-            "build": self.build_args
-        });
-        let arg = serde_json::to_string_pretty(&args_as_json)?;
-        log::info!("using spirv-builder-cli arg: {arg}");
-
         if !self.build_args.watch {
             crate::user_output!(
-                "Running `spirv-builder-cli` to compile shader at {}...\n",
+                "Compiling shaders at {}...\n",
                 self.install.spirv_install.shader_crate.display()
             );
         }
 
-        // TODO Call spirv-builder-cli to compile the shaders.
-        let output = std::process::Command::new("TODO_DUMMY_PLEASE_CHANGE_ME")
-            .arg(arg)
-            .stdout(std::process::Stdio::inherit())
-            .stderr(std::process::Stdio::inherit())
-            .output()?;
-        anyhow::ensure!(output.status.success(), "build failed");
-
-        let spirv_manifest = self.build_args.output_dir.join("spirv-manifest.json");
-        if spirv_manifest.is_file() {
-            log::debug!(
-                "successfully built shaders, raw manifest is at '{}'",
-                spirv_manifest.display()
-            );
-        } else {
-            log::error!("missing raw manifest '{}'", spirv_manifest.display());
-            anyhow::bail!("missing raw manifest");
-        }
-
-        let shaders: Vec<ShaderModule> =
-            serde_json::from_reader(std::fs::File::open(&spirv_manifest)?)?;
-
+        let result = self.build_args.spirv_builder.build()?;
+
+        let shaders = match &result.module {
+            ModuleResult::MultiModule(modules) => {
+                assert!(!modules.is_empty(), "No shader modules to compile");
+                modules.iter().collect::<Vec<_>>()
+            }
+            ModuleResult::SingleModule(filepath) => result
+                .entry_points
+                .iter()
+                .map(|entry| (entry, filepath))
+                .collect::<Vec<_>>(),
+        };
         let mut linkage: Vec<Linkage> = shaders
             .into_iter()
-            .map(
-                |ShaderModule {
-                     entry,
-                     path: filepath,
-                 }|
-                 -> anyhow::Result<Linkage> {
-                    use relative_path::PathExt as _;
-                    let path = self.build_args.output_dir.join(
-                        filepath
-                            .file_name()
-                            .context("Couldn't parse file name from shader module path")?,
-                    );
-                    log::debug!("copying {} to {}", filepath.display(), path.display());
-                    std::fs::copy(&filepath, &path)?;
-                    log::debug!(
-                        "linkage of {} relative to {}",
-                        path.display(),
-                        self.install.spirv_install.shader_crate.display()
-                    );
-                    let spv_path = path
-                        .relative_to(&self.install.spirv_install.shader_crate)
-                        .map_or(path, |path_relative_to_shader_crate| {
-                            path_relative_to_shader_crate.to_path("")
-                        });
-                    Ok(Linkage::new(entry, spv_path))
-                },
-            )
+            .map(|(entry, filepath)| -> anyhow::Result<Linkage> {
+                use relative_path::PathExt as _;
+                let path = self.build_args.output_dir.join(
+                    filepath
+                        .file_name()
+                        .context("Couldn't parse file name from shader module path")?,
+                );
+                log::debug!("copying {} to {}", filepath.display(), path.display());
+                std::fs::copy(&filepath, &path)?;
+                log::debug!(
+                    "linkage of {} relative to {}",
+                    path.display(),
+                    self.install.spirv_install.shader_crate.display()
+                );
+                let spv_path = path
+                    .relative_to(&self.install.spirv_install.shader_crate)
+                    .map_or(path, |path_relative_to_shader_crate| {
+                        path_relative_to_shader_crate.to_path("")
+                    });
+                Ok(Linkage::new(entry, spv_path))
+            })
             .collect::<anyhow::Result<Vec<Linkage>>>()?;
+        // Sort the contents so the output is deterministic
+        linkage.sort();
 
         // Write the shader manifest json file
         let manifest_path = self
             .build_args
             .output_dir
             .join(&self.build_args.manifest_file);
-        // Sort the contents so the output is deterministic
-        linkage.sort();
         let json = serde_json::to_string_pretty(&linkage)?;
         let mut file = std::fs::File::create(&manifest_path).with_context(|| {
             format!(
@@ -152,14 +123,6 @@ impl Build {
         })?;
 
         log::info!("wrote manifest to '{}'", manifest_path.display());
-
-        if spirv_manifest.is_file() {
-            log::debug!(
-                "removing spirv-manifest.json file '{}'",
-                spirv_manifest.display()
-            );
-            std::fs::remove_file(spirv_manifest)?;
-        }
         Ok(())
     }
 }

crates/cargo-gpu/src/build.rs

@@ -8,7 +8,7 @@ use crate::{cache_dir, spirv_source::SpirvSource, target_spec_dir};
 use anyhow::Context as _;
 use log::trace;
 use std::io::Write as _;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 /// Metadata for the compile targets supported by `rust-gpu`
 const TARGET_SPECS: &[(&str, &str)] = &[
@@ -152,8 +152,8 @@ package = "rustc_codegen_spirv"
         Ok(())
     }
 
-    /// Install the binary pair and return the paths, (dylib, cli).
-    pub fn run(&mut self) -> anyhow::Result<()> {
+    /// Install the binary pair and return the `(dylib_path, toolchain_channel)`.
+    pub fn run(&mut self) -> anyhow::Result<(PathBuf, String)> {
         // Ensure the cache dir exists
         let cache_dir = cache_dir()?;
         log::info!("cache directory is '{}'", cache_dir.display());
@@ -191,22 +191,25 @@ package = "rustc_codegen_spirv"
             }
         }
 
-        if !source_is_path
+        let skip_rebuild = !source_is_path
             && dest_dylib_path.is_file()
-            && !self.spirv_install.force_spirv_cli_rebuild
-        {
+            && !self.spirv_install.force_spirv_cli_rebuild;
+        if skip_rebuild {
             log::info!("...and so we are aborting the install step.");
         } else {
             Self::write_source_files(&source, &checkout).context("writing source files")?;
+        }
 
-            log::debug!("resolving toolchain version to use");
-            let rustc_codegen_spirv = get_package_from_crate(&checkout, "rustc_codegen_spirv")
-                .context("get `rustc_codegen_spirv` metadata")?;
-            let toolchain_channel =
-                get_channel_from_rustc_codegen_spirv_build_script(&rustc_codegen_spirv)
-                    .context("read toolchain from `rustc_codegen_spirv`'s build.rs")?;
-            log::info!("selected toolchain channel `{toolchain_channel:?}`");
+        // TODO cache toolchain channel in a file?
+        log::debug!("resolving toolchain version to use");
+        let rustc_codegen_spirv = get_package_from_crate(&checkout, "rustc_codegen_spirv")
+            .context("get `rustc_codegen_spirv` metadata")?;
+        let toolchain_channel =
+            get_channel_from_rustc_codegen_spirv_build_script(&rustc_codegen_spirv)
+                .context("read toolchain from `rustc_codegen_spirv`'s build.rs")?;
+        log::info!("selected toolchain channel `{toolchain_channel:?}`");
 
+        if !skip_rebuild {
             log::debug!("ensure_toolchain_and_components_exist");
             crate::install_toolchain::ensure_toolchain_and_components_exist(
                 &toolchain_channel,
@@ -265,7 +268,7 @@ package = "rustc_codegen_spirv"
                 .context("writing target spec files")?;
         }
 
-        self.spirv_install.dylib_path = dest_dylib_path;
-        Ok(())
+        self.spirv_install.dylib_path = dest_dylib_path.clone();
+        Ok((dest_dylib_path, toolchain_channel))
     }
 }

crates/cargo-gpu/src/install.rs

@@ -34,24 +34,3 @@ impl Linkage {
         self.entry_point.split("::").last().unwrap()
     }
 }
-
-/// A built shader entry-point, used in `spirv-builder-cli` to generate
-/// a `build-manifest.json` used by `cargo-gpu`.
-#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct ShaderModule {
-    /// Name of the entry point for spirv and vulkan
-    pub entry: String,
-    /// File path to the entry point's source file
-    pub path: std::path::PathBuf,
-}
-
-impl ShaderModule {
-    /// Make a new `ShaderModule` from an entry point and source path
-    #[expect(clippy::impl_trait_in_params, reason = "just a struct new")]
-    pub fn new(entry: impl AsRef<str>, path: impl AsRef<std::path::Path>) -> Self {
-        Self {
-            entry: entry.as_ref().into(),
-            path: path.as_ref().into(),
-        }
-    }
-}