Add pica200::include_shader macro using picasso

Author: ian-h-chamberlain

Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
-members = ["citro3d-sys", "citro3d", "bindgen-citro3d"]
-default-members = ["citro3d", "citro3d-sys"]
+members = ["citro3d-sys", "citro3d", "bindgen-citro3d", "pica200"]
+default-members = ["citro3d", "citro3d-sys", "pica200"]
 resolver = "2"
 
 [patch."https://github.com/rust3ds/citro3d-rs.git"]

citro3d/Cargo.toml

@@ -1,11 +1,12 @@
 [package]
 name = "citro3d"
-authors = [ "Rust3DS Org" ]
+authors = ["Rust3DS Org"]
 license = "MIT OR Apache-2.0"
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+pica200 = { version = "0.1.0", path = "../pica200" }
 bitflags = "1.3.2"
 bytemuck = { version = "1.10.0", features = ["extern_crate_std"] }
 citro3d-sys = { git = "https://github.com/rust3ds/citro3d-rs.git" }

citro3d/build.rs

@@ -3,17 +3,15 @@
 
 #![feature(allocator_api)]
 
-use citro3d::attrib::{self};
-use citro3d::buffer::{self};
+use std::ffi::CStr;
+use std::mem::MaybeUninit;
+
 use citro3d::render::{ClearFlags, Target};
-use citro3d::{include_aligned_bytes, shader};
+use citro3d::{attrib, buffer, shader};
 use citro3d_sys::C3D_Mtx;
 use ctru::prelude::*;
 use ctru::services::gfx::{RawFrameBuffer, Screen, TopScreen3D};
 
-use std::ffi::CStr;
-use std::mem::MaybeUninit;
-
 #[repr(C)]
 #[derive(Copy, Clone)]
 struct Vec3 {
@@ -50,8 +48,7 @@ static VERTICES: &[Vertex] = &[
     },
 ];
 
-static SHADER_BYTES: &[u8] =
-    include_aligned_bytes!(concat!(env!("OUT_DIR"), "/examples/assets/vshader.shbin"));
+static SHADER_BYTES: &[u8] = citro3d::include_shader!("assets/vshader.pica");
 
 fn main() {
     ctru::use_panic_handler();

citro3d/examples/triangle.rs

@@ -8,6 +8,7 @@ pub mod shader;
 
 use citro3d_sys::C3D_FrameDrawOn;
 pub use error::{Error, Result};
+pub use pica200::include_shader;
 
 /// The single instance for using `citro3d`. This is the base type that an application
 /// should instantiate to use this library.

citro3d/src/lib.rs

@@ -7,11 +7,6 @@
 use std::error::Error;
 use std::mem::MaybeUninit;
 
-// Macros get exported at the crate root, so no reason to document this module.
-// It still needs to be `pub` for the helper struct it exports.
-#[doc(hidden)]
-pub mod macros;
-
 /// A PICA200 shader program. It may have one or both of:
 ///
 /// * A vertex shader [`Library`]

citro3d/src/shader.rs

@@ -0,0 +1,13 @@
+[package]
+name = "pica200"
+version = "0.1.0"
+edition = "2021"
+authors = ["Rust3DS Org"]
+license = "MIT OR Apache-2.0"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+litrs = { version = "0.4.0", default-features = false }
+quote = "1.0.32"

citro3d/src/shader/macros.rs

@@ -0,0 +1,8 @@
+//! This build script mainly exists just to ensure `OUT_DIR` is set for the macro,
+//! but we can also use it to force a re-evaluation if `DEVKITPRO` changes.
+
+fn main() {
+    for var in ["OUT_DIR", "DEVKITPRO"] {
+        println!("cargo:rerun-if-env-changed={var}");
+    }
+}

pica200/Cargo.toml

@@ -0,0 +1,115 @@
+// we're already nightly-only so might as well use unstable proc macro APIs.
+#![feature(proc_macro_span)]
+
+use std::path::PathBuf;
+use std::{env, process};
+
+use litrs::StringLit;
+use quote::quote;
+
+/// Compiles the given PICA200 shader using [`picasso`](https://github.com/devkitPro/picasso)
+/// and returns the compiled bytes directly as a `&[u8]` slice.
+///
+/// This is similar to the standard library's [`include_bytes!`] macro, for which
+/// file paths are relative to the source file where the macro is invoked.
+///
+/// The compiled shader binary will be saved in the caller's `$OUT_DIR`.
+///
+/// # Errors
+///
+/// This macro will fail to compile if the input is not a single string literal.
+/// In other words, inputs like `concat!("foo", "/bar")` are not supported.
+///
+/// # Example
+///
+/// ```no_run
+/// # use pica200::include_shader;
+/// static SHADER_BYTES: &[u8] = include_shader!("assets/vshader.pica");
+/// ```
+#[proc_macro]
+pub fn include_shader(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let tokens: Vec<_> = input.into_iter().collect();
+
+    if tokens.len() != 1 {
+        let msg = format!("expected exactly one input token, got {}", tokens.len());
+        return quote! { compile_error!(#msg) }.into();
+    }
+
+    let string_lit = match StringLit::try_from(&tokens[0]) {
+        // Error if the token is not a string literal
+        Err(e) => return e.to_compile_error(),
+        Ok(lit) => lit,
+    };
+
+    // The cwd can change depending on whether this is running in a doctest or not:
+    // https://users.rust-lang.org/t/which-directory-does-a-proc-macro-run-from/71917
+    //
+    // But the span's `source_file()` seems to always be relative to the cwd.
+    let cwd = env::current_dir().expect("unable to determine working directory");
+    let invoking_source_file = tokens[0].span().source_file().path();
+    let invoking_source_dir = invoking_source_file
+        .parent()
+        .expect("unable to find parent directory of invoking source file");
+
+    // By joining these three pieces, we arrive at approximately the same behavior as `include_bytes!`
+    let shader_source_file = cwd.join(invoking_source_dir).join(string_lit.value());
+    let shader_out_file = shader_source_file.with_extension("shbin");
+
+    let Some(shader_out_file) = shader_out_file.file_name() else {
+        let msg = format!("invalid input file name {shader_source_file:?}");
+        return quote! { compile_error!(#msg) }.into();
+    };
+
+    let out_dir = PathBuf::from(env!("OUT_DIR"));
+    let out_path = out_dir.join(shader_out_file);
+
+    let devkitpro = PathBuf::from(env!("DEVKITPRO"));
+
+    let output = process::Command::new(devkitpro.join("tools/bin/picasso"))
+        .arg("--out")
+        .args([&out_path, &shader_source_file])
+        .output()
+        .unwrap();
+
+    match output.status.code() {
+        Some(0) => {}
+        code => {
+            let code = code.map_or_else(|| String::from("unknown"), |c| c.to_string());
+
+            let msg = format!(
+                "failed to compile shader {shader_source_file:?}: exit status {code}: {}",
+                String::from_utf8_lossy(&output.stderr),
+            );
+
+            return quote! { compile_error!(#msg) }.into();
+        }
+    }
+
+    let bytes = std::fs::read(out_path).unwrap();
+    let source_file_path = shader_source_file.to_string_lossy();
+
+    let result = quote! {
+        {
+            // ensure the source is re-evaluted if the input file changes
+            const _SOURCE: &[u8] = include_bytes! ( #source_file_path );
+
+            // https://users.rust-lang.org/t/can-i-conveniently-compile-bytes-into-a-rust-program-with-a-specific-alignment/24049/2
+            #[repr(C)]
+            struct AlignedAsU32<Bytes: ?Sized> {
+                _align: [u32; 0],
+                bytes: Bytes,
+            }
+
+            // this assignment is made possible by CoerceUnsized
+            const ALIGNED: &AlignedAsU32<[u8]> = &AlignedAsU32 {
+                _align: [],
+                // emits a token stream like `[10u8, 11u8, ... ]`
+                bytes: [ #(#bytes),* ]
+            };
+
+            &ALIGNED.bytes
+        }
+    };
+
+    result.into()
+}