1#![cfg_attr(not(target_os = "macos"), allow(unused))]
2
3use std::{
4 env,
5 path::{Path, PathBuf},
6};
7
8use cbindgen::Config;
9
10fn main() {
11 #[cfg(target_os = "macos")]
12 generate_dispatch_bindings();
13 #[cfg(target_os = "macos")]
14 let header_path = generate_shader_bindings();
15 #[cfg(target_os = "macos")]
16 #[cfg(feature = "runtime_shaders")]
17 emit_stitched_shaders(&header_path);
18 #[cfg(target_os = "macos")]
19 #[cfg(not(feature = "runtime_shaders"))]
20 compile_metal_shaders(&header_path);
21}
22
23fn generate_dispatch_bindings() {
24 println!("cargo:rustc-link-lib=framework=System");
25 println!("cargo:rerun-if-changed=src/platform/mac/dispatch.h");
26
27 let bindings = bindgen::Builder::default()
28 .header("src/platform/mac/dispatch.h")
29 .allowlist_var("_dispatch_main_q")
30 .allowlist_var("DISPATCH_QUEUE_PRIORITY_DEFAULT")
31 .allowlist_var("DISPATCH_QUEUE_PRIORITY_HIGH")
32 .allowlist_var("DISPATCH_TIME_NOW")
33 .allowlist_function("dispatch_get_global_queue")
34 .allowlist_function("dispatch_async_f")
35 .allowlist_function("dispatch_after_f")
36 .allowlist_function("dispatch_time")
37 .parse_callbacks(Box::new(bindgen::CargoCallbacks))
38 .layout_tests(false)
39 .generate()
40 .expect("unable to generate bindings");
41
42 let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
43 bindings
44 .write_to_file(out_path.join("dispatch_sys.rs"))
45 .expect("couldn't write dispatch bindings");
46}
47
48fn generate_shader_bindings() -> PathBuf {
49 let output_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("scene.h");
50 let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
51 let mut config = Config::default();
52 config.include_guard = Some("SCENE_H".into());
53 config.language = cbindgen::Language::C;
54 config.export.include.extend([
55 "Bounds".into(),
56 "Corners".into(),
57 "Edges".into(),
58 "Size".into(),
59 "Pixels".into(),
60 "PointF".into(),
61 "Hsla".into(),
62 "ContentMask".into(),
63 "Uniforms".into(),
64 "AtlasTile".into(),
65 "PathRasterizationInputIndex".into(),
66 "PathVertex_ScaledPixels".into(),
67 "ShadowInputIndex".into(),
68 "Shadow".into(),
69 "QuadInputIndex".into(),
70 "Underline".into(),
71 "UnderlineInputIndex".into(),
72 "Quad".into(),
73 "SpriteInputIndex".into(),
74 "MonochromeSprite".into(),
75 "PolychromeSprite".into(),
76 "PathSprite".into(),
77 "SurfaceInputIndex".into(),
78 "SurfaceBounds".into(),
79 ]);
80 config.no_includes = true;
81 config.enumeration.prefix_with_name = true;
82
83 let mut builder = cbindgen::Builder::new();
84
85 let src_paths = [
86 crate_dir.join("src/scene.rs"),
87 crate_dir.join("src/geometry.rs"),
88 crate_dir.join("src/color.rs"),
89 crate_dir.join("src/window.rs"),
90 crate_dir.join("src/platform.rs"),
91 crate_dir.join("src/platform/mac/metal_renderer.rs"),
92 ];
93 for src_path in src_paths {
94 println!("cargo:rerun-if-changed={}", src_path.display());
95 builder = builder.with_src(src_path);
96 }
97
98 builder
99 .with_config(config)
100 .generate()
101 .expect("Unable to generate bindings")
102 .write_to_file(&output_path);
103
104 output_path
105}
106
107/// To enable runtime compilation, we need to "stitch" the shaders file with the generated header
108/// so that it is self-contained.
109#[cfg(feature = "runtime_shaders")]
110fn emit_stitched_shaders(header_path: &Path) {
111 use std::str::FromStr;
112 fn stitch_header(header: &Path, shader_path: &Path) -> std::io::Result<PathBuf> {
113 let header_contents = std::fs::read_to_string(header)?;
114 let shader_contents = std::fs::read_to_string(shader_path)?;
115 let stitched_contents = format!("{header_contents}\n{shader_contents}");
116 let out_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("stitched_shaders.metal");
117 let _ = std::fs::write(&out_path, stitched_contents)?;
118 Ok(out_path)
119 }
120 let shader_source_path = "./src/platform/mac/shaders.metal";
121 let shader_path = PathBuf::from_str(shader_source_path).unwrap();
122 stitch_header(header_path, &shader_path).unwrap();
123 println!("cargo:rerun-if-changed={}", &shader_source_path);
124}
125#[cfg(not(feature = "runtime_shaders"))]
126fn compile_metal_shaders(header_path: &Path) {
127 use std::process::{self, Command};
128 let shader_path = "./src/platform/mac/shaders.metal";
129 let air_output_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("shaders.air");
130 let metallib_output_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("shaders.metallib");
131 println!("cargo:rerun-if-changed={}", shader_path);
132
133 let output = Command::new("xcrun")
134 .args([
135 "-sdk",
136 "macosx",
137 "metal",
138 "-gline-tables-only",
139 "-mmacosx-version-min=10.15.7",
140 "-MO",
141 "-c",
142 shader_path,
143 "-include",
144 &header_path.to_str().unwrap(),
145 "-o",
146 ])
147 .arg(&air_output_path)
148 .output()
149 .unwrap();
150
151 if !output.status.success() {
152 eprintln!(
153 "metal shader compilation failed:\n{}",
154 String::from_utf8_lossy(&output.stderr)
155 );
156 process::exit(1);
157 }
158
159 let output = Command::new("xcrun")
160 .args(["-sdk", "macosx", "metallib"])
161 .arg(air_output_path)
162 .arg("-o")
163 .arg(metallib_output_path)
164 .output()
165 .unwrap();
166
167 if !output.status.success() {
168 eprintln!(
169 "metallib compilation failed:\n{}",
170 String::from_utf8_lossy(&output.stderr)
171 );
172 process::exit(1);
173 }
174}