1#![cfg_attr(any(not(target_os = "macos"), feature = "macos-blade"), allow(unused))]
2
3//TODO: consider generating shader code for WGSL
4//TODO: deprecate "runtime-shaders" and "macos-blade"
5
6use std::env;
7
8fn main() {
9 let target = env::var("CARGO_CFG_TARGET_OS");
10 println!("cargo::rustc-check-cfg=cfg(gles)");
11
12 #[cfg(any(not(target_os = "macos"), feature = "macos-blade"))]
13 check_wgsl_shaders();
14
15 match target.as_deref() {
16 Ok("macos") => {
17 #[cfg(target_os = "macos")]
18 macos::build();
19 }
20 #[cfg(target_os = "windows")]
21 Ok("windows") => {
22 let manifest = std::path::Path::new("resources/windows/gpui.manifest.xml");
23 let rc_file = std::path::Path::new("resources/windows/gpui.rc");
24 println!("cargo:rerun-if-changed={}", manifest.display());
25 println!("cargo:rerun-if-changed={}", rc_file.display());
26 embed_resource::compile(rc_file, embed_resource::NONE)
27 .manifest_required()
28 .unwrap();
29 }
30 _ => (),
31 };
32}
33
34#[allow(dead_code)]
35fn check_wgsl_shaders() {
36 use std::path::PathBuf;
37 use std::process;
38 use std::str::FromStr;
39
40 let shader_source_path = "./src/platform/blade/shaders.wgsl";
41 let shader_path = PathBuf::from_str(shader_source_path).unwrap();
42 println!("cargo:rerun-if-changed={}", &shader_path.display());
43
44 let shader_source = std::fs::read_to_string(&shader_path).unwrap();
45
46 match naga::front::wgsl::parse_str(&shader_source) {
47 Ok(_) => {
48 // All clear
49 }
50 Err(e) => {
51 eprintln!("WGSL shader compilation failed:\n{}", e);
52 process::exit(1);
53 }
54 }
55}
56#[cfg(target_os = "macos")]
57mod macos {
58 use std::{
59 env,
60 path::{Path, PathBuf},
61 };
62
63 use cbindgen::Config;
64
65 pub(super) fn build() {
66 generate_dispatch_bindings();
67 #[cfg(not(feature = "macos-blade"))]
68 {
69 let header_path = generate_shader_bindings();
70
71 #[cfg(feature = "runtime_shaders")]
72 emit_stitched_shaders(&header_path);
73 #[cfg(not(feature = "runtime_shaders"))]
74 compile_metal_shaders(&header_path);
75 }
76 }
77
78 fn generate_dispatch_bindings() {
79 println!("cargo:rustc-link-lib=framework=System");
80 println!("cargo:rustc-link-lib=framework=ScreenCaptureKit");
81 println!("cargo:rerun-if-changed=src/platform/mac/dispatch.h");
82
83 let bindings = bindgen::Builder::default()
84 .header("src/platform/mac/dispatch.h")
85 .allowlist_var("_dispatch_main_q")
86 .allowlist_var("_dispatch_source_type_data_add")
87 .allowlist_var("DISPATCH_QUEUE_PRIORITY_HIGH")
88 .allowlist_var("DISPATCH_TIME_NOW")
89 .allowlist_function("dispatch_get_global_queue")
90 .allowlist_function("dispatch_async_f")
91 .allowlist_function("dispatch_after_f")
92 .allowlist_function("dispatch_time")
93 .allowlist_function("dispatch_source_merge_data")
94 .allowlist_function("dispatch_source_create")
95 .allowlist_function("dispatch_source_set_event_handler_f")
96 .allowlist_function("dispatch_resume")
97 .allowlist_function("dispatch_suspend")
98 .allowlist_function("dispatch_source_cancel")
99 .allowlist_function("dispatch_set_context")
100 .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
101 .layout_tests(false)
102 .generate()
103 .expect("unable to generate bindings");
104
105 let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
106 bindings
107 .write_to_file(out_path.join("dispatch_sys.rs"))
108 .expect("couldn't write dispatch bindings");
109 }
110
111 fn generate_shader_bindings() -> PathBuf {
112 let output_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("scene.h");
113 let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
114 let mut config = Config {
115 include_guard: Some("SCENE_H".into()),
116 language: cbindgen::Language::C,
117 no_includes: true,
118 ..Default::default()
119 };
120 config.export.include.extend([
121 "Bounds".into(),
122 "Corners".into(),
123 "Edges".into(),
124 "Size".into(),
125 "Pixels".into(),
126 "PointF".into(),
127 "Hsla".into(),
128 "ContentMask".into(),
129 "Uniforms".into(),
130 "AtlasTile".into(),
131 "PathRasterizationInputIndex".into(),
132 "PathVertex_ScaledPixels".into(),
133 "ShadowInputIndex".into(),
134 "Shadow".into(),
135 "QuadInputIndex".into(),
136 "Underline".into(),
137 "UnderlineInputIndex".into(),
138 "Quad".into(),
139 "BorderStyle".into(),
140 "SpriteInputIndex".into(),
141 "MonochromeSprite".into(),
142 "PolychromeSprite".into(),
143 "PathSprite".into(),
144 "SurfaceInputIndex".into(),
145 "SurfaceBounds".into(),
146 "TransformationMatrix".into(),
147 ]);
148 config.no_includes = true;
149 config.enumeration.prefix_with_name = true;
150
151 let mut builder = cbindgen::Builder::new();
152
153 let src_paths = [
154 crate_dir.join("src/scene.rs"),
155 crate_dir.join("src/geometry.rs"),
156 crate_dir.join("src/color.rs"),
157 crate_dir.join("src/window.rs"),
158 crate_dir.join("src/platform.rs"),
159 crate_dir.join("src/platform/mac/metal_renderer.rs"),
160 ];
161 for src_path in src_paths {
162 println!("cargo:rerun-if-changed={}", src_path.display());
163 builder = builder.with_src(src_path);
164 }
165
166 builder
167 .with_config(config)
168 .generate()
169 .expect("Unable to generate bindings")
170 .write_to_file(&output_path);
171
172 output_path
173 }
174
175 /// To enable runtime compilation, we need to "stitch" the shaders file with the generated header
176 /// so that it is self-contained.
177 #[cfg(feature = "runtime_shaders")]
178 fn emit_stitched_shaders(header_path: &Path) {
179 use std::str::FromStr;
180 fn stitch_header(header: &Path, shader_path: &Path) -> std::io::Result<PathBuf> {
181 let header_contents = std::fs::read_to_string(header)?;
182 let shader_contents = std::fs::read_to_string(shader_path)?;
183 let stitched_contents = format!("{header_contents}\n{shader_contents}");
184 let out_path =
185 PathBuf::from(env::var("OUT_DIR").unwrap()).join("stitched_shaders.metal");
186 std::fs::write(&out_path, stitched_contents)?;
187 Ok(out_path)
188 }
189 let shader_source_path = "./src/platform/mac/shaders.metal";
190 let shader_path = PathBuf::from_str(shader_source_path).unwrap();
191 stitch_header(header_path, &shader_path).unwrap();
192 println!("cargo:rerun-if-changed={}", &shader_source_path);
193 }
194
195 #[cfg(not(feature = "runtime_shaders"))]
196 fn compile_metal_shaders(header_path: &Path) {
197 use std::process::{self, Command};
198 let shader_path = "./src/platform/mac/shaders.metal";
199 let air_output_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("shaders.air");
200 let metallib_output_path =
201 PathBuf::from(env::var("OUT_DIR").unwrap()).join("shaders.metallib");
202 println!("cargo:rerun-if-changed={}", shader_path);
203
204 let output = Command::new("xcrun")
205 .args([
206 "-sdk",
207 "macosx",
208 "metal",
209 "-gline-tables-only",
210 "-mmacosx-version-min=10.15.7",
211 "-MO",
212 "-c",
213 shader_path,
214 "-include",
215 (header_path.to_str().unwrap()),
216 "-o",
217 ])
218 .arg(&air_output_path)
219 .output()
220 .unwrap();
221
222 if !output.status.success() {
223 eprintln!(
224 "metal shader compilation failed:\n{}",
225 String::from_utf8_lossy(&output.stderr)
226 );
227 process::exit(1);
228 }
229
230 let output = Command::new("xcrun")
231 .args(["-sdk", "macosx", "metallib"])
232 .arg(air_output_path)
233 .arg("-o")
234 .arg(metallib_output_path)
235 .output()
236 .unwrap();
237
238 if !output.status.success() {
239 eprintln!(
240 "metallib compilation failed:\n{}",
241 String::from_utf8_lossy(&output.stderr)
242 );
243 process::exit(1);
244 }
245 }
246}