Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

perf(compositor): compile the Windows shaders at build time

EtienneLescot0c749073decb
diff --git a/crates/Cargo.toml b/crates/Cargo.toml
index abd74df99..3caa7edfd 100644
--- a/crates/Cargo.toml
+++ b/crates/Cargo.toml
@@ -60,7 +60,6 @@ version = "0.58"
features = [
"Win32_Foundation",
"Win32_Graphics_Direct3D",
- "Win32_Graphics_Direct3D_Fxc", # D3DCompile (HLSL runtime)
"Win32_Graphics_Direct3D11",
"Win32_Graphics_Dxgi",
"Win32_Graphics_Dxgi_Common",
diff --git a/crates/README.md b/crates/README.md
index 605c5a366..5613ecdfc 100644
--- a/crates/README.md
+++ b/crates/README.md
@@ -49,7 +49,7 @@ compositeur (WGSL natif à l'identique) + la carte des coûts.
- **ffmpeg (libav\*)** LGPL pour demux / décode D3D11VA / encode `h264_amf` / mux. Bindings
générés par `bindgen` (choix vs `ffmpeg-next` : suit ffmpeg 8.x — voir [`technical-documentation/architecture/native-compositor.md`](../technical-documentation/architecture/native-compositor.md)),
shim C (`shim.c`) pour les structs opaques.
-- Compositeur HLSL (`src/shaders.hlsl`) compilé au runtime.
+- Compositeur HLSL (`src/shaders.hlsl`) compilé au build (`build.rs`), embarqué en bytecode.
## Prérequis
diff --git a/crates/compositor/Cargo.toml b/crates/compositor/Cargo.toml
index face980ee..cc9ef6459 100644
--- a/crates/compositor/Cargo.toml
+++ b/crates/compositor/Cargo.toml
@@ -2,7 +2,7 @@
name = "openscreen-compositor"
version.workspace = true
edition.workspace = true
-description = "Compositeur natif multiplateforme d'OpenScreen : décodage, pipeline, effets, scène, curseur, audio, et la vue live embarquable. Code de production — l'addon Electron (compositor-view-napi) s'y lie, le POC (poc-d3d) le consomme aussi.\n\nWindows : D3D11 + D3D11VA + shaders HLSL compilés à l'exécution. macOS : Metal + VideoToolbox + shaders MSL (port de ce PR)."
+description = "Compositeur natif multiplateforme d'OpenScreen : décodage, pipeline, effets, scène, curseur, audio, et la vue live embarquable. Code de production — l'addon Electron (compositor-view-napi) s'y lie, le POC (poc-d3d) le consomme aussi.\n\nWindows : D3D11 + D3D11VA + shaders HLSL compilés au build (build.rs). macOS : Metal + VideoToolbox + shaders MSL (port de ce PR)."
[lib]
name = "openscreen_compositor"
@@ -12,6 +12,11 @@ path = "src/lib.rs"
bindgen = "0.70"
cc = "1"
+# D3DCompile, pour compiler `shaders.hlsl` au build (`compile_hlsl` dans build.rs). La version
+# est celle du workspace ; les features, les deux seules dont le build a besoin.
+[target.'cfg(windows)'.build-dependencies]
+windows = { version = "0.58", features = ["Win32_Graphics_Direct3D", "Win32_Graphics_Direct3D_Fxc"] }
+
[features]
default = ["segmentation"]
# Segmentation IA de la webcam via ONNX Runtime (EP CPU).
diff --git a/crates/compositor/build.rs b/crates/compositor/build.rs
index 99b11e2f6..66f465153 100644
--- a/crates/compositor/build.rs
+++ b/crates/compositor/build.rs
@@ -171,6 +171,73 @@ fn main() {
if let Ok(prefix) = env::var("OPENSCREEN_FFMPEG_SYMBOL_PREFIX") {
prefix_ffmpeg_symbols(&ffi_path, &prefix);
}
+
+ // `cfg(windows)` = l'HÔTE : d3dcompiler n'existe que là, et la cible Windows ne se
+ // construit que depuis Windows (MSVC, import libs ffmpeg).
+ if target_os == "windows" {
+ #[cfg(windows)]
+ compile_hlsl(&out);
+ }
+}
+
+/// Les shaders du compositeur Windows (`src/shaders.hlsl`), compilés ICI et embarqués en
+/// bytecode (`shader!` dans `compositor_windows.rs`), plutôt qu'à chaque construction d'un
+/// `Compositor`. À l'exécution, FXC y passait plusieurs secondes sur l'uber-shader (0,5 s à la
+/// mi-septembre 2026, 4 à 16 s selon la charge dix jours plus tard), payées deux fois à
+/// l'ouverture d'un projet et une fois à chaque changement de taille de rendu : autant de temps
+/// sans image dans la preview. Une faute dans le HLSL fait maintenant échouer `cargo check`, au
+/// lieu de l'exécution.
+#[cfg(windows)]
+fn compile_hlsl(out: &Path) {
+ use windows::core::PCSTR;
+ use windows::Win32::Graphics::Direct3D::Fxc::{D3DCompile, D3DCOMPILE_OPTIMIZATION_LEVEL3};
+ use windows::Win32::Graphics::Direct3D::ID3DBlob;
+
+ fn blob_bytes(blob: &ID3DBlob) -> Vec<u8> {
+ unsafe {
+ std::slice::from_raw_parts(blob.GetBufferPointer() as *const u8, blob.GetBufferSize())
+ .to_vec()
+ }
+ }
+
+ const SRC: &str = "src/shaders.hlsl";
+ println!("cargo:rerun-if-changed={SRC}");
+ let hlsl = std::fs::read(SRC).expect(SRC);
+ // Tous les points d'entrée que `Compositor::new_inner` instancie, avec leur profil.
+ for (entry, profile) in [
+ ("vs_main", "vs_5_0"),
+ ("ps_main", "ps_5_0"),
+ ("vs_fs", "vs_5_0"),
+ ("ps_y", "ps_5_0"),
+ ("ps_uv", "ps_5_0"),
+ ("ps_blur", "ps_5_0"),
+ ("ps_tex", "ps_5_0"),
+ ("ps_kawase_down", "ps_5_0"),
+ ("ps_kawase_up", "ps_5_0"),
+ ] {
+ let (entry_z, profile_z) = (format!("{entry}\0"), format!("{profile}\0"));
+ let (mut code, mut errors): (Option<ID3DBlob>, Option<ID3DBlob>) = (None, None);
+ let compiled = unsafe {
+ D3DCompile(
+ hlsl.as_ptr().cast(),
+ hlsl.len(),
+ PCSTR(b"shaders.hlsl\0".as_ptr()),
+ None,
+ None,
+ PCSTR(entry_z.as_ptr()),
+ PCSTR(profile_z.as_ptr()),
+ D3DCOMPILE_OPTIMIZATION_LEVEL3,
+ 0,
+ &mut code,
+ Some(&mut errors),
+ )
+ };
+ if let Err(e) = compiled {
+ let log = errors.as_ref().map(blob_bytes).unwrap_or_default();
+ panic!("{SRC} : {entry} ne compile pas ({e})\n{}", String::from_utf8_lossy(&log));
+ }
+ std::fs::write(out.join(format!("{entry}.cso")), blob_bytes(&code.unwrap())).expect(entry);
+ }
}
/// Flags `-I` supplémentaires pour que clang trouve les en-têtes « freestanding » qu'il
diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs
index b2443f7f0..8a95d1f06 100644
--- a/crates/compositor/src/compositor_windows.rs
+++ b/crates/compositor/src/compositor_windows.rs
@@ -23,10 +23,9 @@ use anyhow::{bail, Result};
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::ffi::c_void;
-use windows::core::{Interface, PCSTR};
-use windows::Win32::Graphics::Direct3D::Fxc::{D3DCompile, D3DCOMPILE_OPTIMIZATION_LEVEL3};
+use windows::core::Interface;
use windows::Win32::Graphics::Direct3D::{
- ID3DBlob, D3D11_SRV_DIMENSION_TEXTURE2DARRAY, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
+ D3D11_SRV_DIMENSION_TEXTURE2DARRAY, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
};
use windows::Win32::Graphics::Direct3D11::*;
use windows::Win32::Graphics::Dxgi::Common::*;
@@ -269,33 +268,12 @@ struct ResizeTarget {
-unsafe fn compile(src: &[u8], entry: &[u8], target: &[u8]) -> Result<ID3DBlob> {
- let mut code: Option<ID3DBlob> = None;
- let mut err: Option<ID3DBlob> = None;
- let r = D3DCompile(
- src.as_ptr() as *const c_void,
- src.len(),
- PCSTR::null(),
- None,
- None,
- PCSTR(entry.as_ptr()),
- PCSTR(target.as_ptr()),
- D3DCOMPILE_OPTIMIZATION_LEVEL3,
- 0,
- &mut code,
- Some(&mut err),
- );
- if r.is_err() {
- if let Some(e) = err {
- let msg = std::slice::from_raw_parts(
- e.GetBufferPointer() as *const u8,
- e.GetBufferSize(),
- );
- bail!("D3DCompile {}: {}", String::from_utf8_lossy(entry), String::from_utf8_lossy(msg));
- }
- bail!("D3DCompile a échoué");
- }
- Ok(code.unwrap())
+/// Bytecode d'un point d'entrée de `shaders.hlsl`, compilé par `build.rs` (`compile_hlsl`) :
+/// aucun `D3DCompile` à l'exécution, donc rien à payer quand le compositeur se construit.
+macro_rules! shader {
+ ($entry:literal) => {
+ include_bytes!(concat!(env!("OUT_DIR"), "/", $entry, ".cso"))
+ };
}
impl Compositor {
@@ -370,34 +348,18 @@ impl Compositor {
dev.CreateTexture2D(&td, None, Some(&mut staging))?;
// --- shaders ---
- let hlsl = include_bytes!("shaders.hlsl");
- let vsb = compile(hlsl, b"vs_main\0", b"vs_5_0\0")?;
- let psb = compile(hlsl, b"ps_main\0", b"ps_5_0\0")?;
- let vs_bytes =
- std::slice::from_raw_parts(vsb.GetBufferPointer() as *const u8, vsb.GetBufferSize());
- let ps_bytes =
- std::slice::from_raw_parts(psb.GetBufferPointer() as *const u8, psb.GetBufferSize());
let mut vs: Option<ID3D11VertexShader> = None;
- dev.CreateVertexShader(vs_bytes, None, Some(&mut vs))?;
+ dev.CreateVertexShader(shader!("vs_main"), None, Some(&mut vs))?;
let mut ps: Option<ID3D11PixelShader> = None;
- dev.CreatePixelShader(ps_bytes, None, Some(&mut ps))?;
+ dev.CreatePixelShader(shader!("ps_main"), None, Some(&mut ps))?;
// shaders RGB->NV12
- let fsb = compile(hlsl, b"vs_fs\0", b"vs_5_0\0")?;
- let yb = compile(hlsl, b"ps_y\0", b"ps_5_0\0")?;
- let uvb = compile(hlsl, b"ps_uv\0", b"ps_5_0\0")?;
- let fs_bytes =
- std::slice::from_raw_parts(fsb.GetBufferPointer() as *const u8, fsb.GetBufferSize());
- let y_bytes =
- std::slice::from_raw_parts(yb.GetBufferPointer() as *const u8, yb.GetBufferSize());
- let uv_bytes =
- std::slice::from_raw_parts(uvb.GetBufferPointer() as *const u8, uvb.GetBufferSize());
let mut vs_fs: Option<ID3D11VertexShader> = None;
- dev.CreateVertexShader(fs_bytes, None, Some(&mut vs_fs))?;
+ dev.CreateVertexShader(shader!("vs_fs"), None, Some(&mut vs_fs))?;
let mut ps_y: Option<ID3D11PixelShader> = None;
- dev.CreatePixelShader(y_bytes, None, Some(&mut ps_y))?;
+ dev.CreatePixelShader(shader!("ps_y"), None, Some(&mut ps_y))?;
let mut ps_uv: Option<ID3D11PixelShader> = None;
- dev.CreatePixelShader(uv_bytes, None, Some(&mut ps_uv))?;
+ dev.CreatePixelShader(shader!("ps_uv"), None, Some(&mut ps_uv))?;
// --- sampler bilinéaire clamp ---
let sd = D3D11_SAMPLER_DESC {
@@ -477,36 +439,16 @@ impl Compositor {
let rtv_uv = mk_rtv(DXGI_FORMAT_R8G8_UNORM)?;
// shaders de flou + copie
- let blurb = compile(hlsl, b"ps_blur\0", b"ps_5_0\0")?;
- let texb = compile(hlsl, b"ps_tex\0", b"ps_5_0\0")?;
let mut ps_blur: Option<ID3D11PixelShader> = None;
- dev.CreatePixelShader(
- std::slice::from_raw_parts(blurb.GetBufferPointer() as *const u8, blurb.GetBufferSize()),
- None,
- Some(&mut ps_blur),
- )?;
+ dev.CreatePixelShader(shader!("ps_blur"), None, Some(&mut ps_blur))?;
let mut ps_tex: Option<ID3D11PixelShader> = None;
- dev.CreatePixelShader(
- std::slice::from_raw_parts(texb.GetBufferPointer() as *const u8, texb.GetBufferSize()),
- None,
- Some(&mut ps_tex),
- )?;
+ dev.CreatePixelShader(shader!("ps_tex"), None, Some(&mut ps_tex))?;
// shaders dual-Kawase
- let kdb = compile(hlsl, b"ps_kawase_down\0", b"ps_5_0\0")?;
- let kub = compile(hlsl, b"ps_kawase_up\0", b"ps_5_0\0")?;
let mut ps_kdown: Option<ID3D11PixelShader> = None;
- dev.CreatePixelShader(
- std::slice::from_raw_parts(kdb.GetBufferPointer() as *const u8, kdb.GetBufferSize()),
- None,
- Some(&mut ps_kdown),
- )?;
+ dev.CreatePixelShader(shader!("ps_kawase_down"), None, Some(&mut ps_kdown))?;
let mut ps_kup: Option<ID3D11PixelShader> = None;
- dev.CreatePixelShader(
- std::slice::from_raw_parts(kub.GetBufferPointer() as *const u8, kub.GetBufferSize()),
- None,
- Some(&mut ps_kup),
- )?;
+ dev.CreatePixelShader(shader!("ps_kawase_up"), None, Some(&mut ps_kup))?;
// textures RGBA RT+SRV à une taille donnée (chaîne de flou)
let mk_rgba = |w: u32, h: u32| -> Result<(ID3D11RenderTargetView, ID3D11ShaderResourceView)> {
@@ -3155,30 +3097,4 @@ mod tests {
cumule / 1048576
);
}
-
-
- /// Le HLSL est compilé au démarrage du compositeur : jusqu'ici une faute dedans ne se voyait
- /// qu'à l'exécution, donc après un rebuild du natif ET un relancement de l'app. `D3DCompile`
- /// ne demande aucun device — le compilateur seul suffit, et ça tient en quelques
- /// millisecondes.
- #[test]
- fn every_shader_entry_point_compiles() {
- let hlsl = include_bytes!("shaders.hlsl");
- for (entry, target) in [
- (&b"vs_main\0"[..], &b"vs_5_0\0"[..]),
- (&b"ps_main\0"[..], &b"ps_5_0\0"[..]),
- (&b"vs_fs\0"[..], &b"vs_5_0\0"[..]),
- (&b"ps_y\0"[..], &b"ps_5_0\0"[..]),
- (&b"ps_uv\0"[..], &b"ps_5_0\0"[..]),
- (&b"ps_blur\0"[..], &b"ps_5_0\0"[..]),
- (&b"ps_tex\0"[..], &b"ps_5_0\0"[..]),
- (&b"ps_kawase_down\0"[..], &b"ps_5_0\0"[..]),
- (&b"ps_kawase_up\0"[..], &b"ps_5_0\0"[..]),
- ] {
- let name = String::from_utf8_lossy(&entry[..entry.len() - 1]).to_string();
- unsafe { compile(hlsl, entry, target) }
- .unwrap_or_else(|e| panic!("{name} ne compile pas : {e}"));
- }
- }
-
}
diff --git a/crates/compositor/src/lib.rs b/crates/compositor/src/lib.rs
index 84ca881fe..ed0222a43 100644
--- a/crates/compositor/src/lib.rs
+++ b/crates/compositor/src/lib.rs
@@ -9,7 +9,7 @@
//! # Backends
//!
//! - Windows : `d3d_windows::Gpu` (D3D11 + D3D11VA), shaders HLSL compilés via `D3DCompile`
-//! à l'exécution, `cpu_frames_windows.rs` pour l'axe décodage logiciel du backend CPU.
+//! au build (`build.rs`), `cpu_frames_windows.rs` pour l'axe décodage logiciel du backend CPU.
//! Le moteur est dans `compositor_windows.rs` et le rastériseur de texte dans `text_windows.rs`.
//!
//! - macOS : `d3d_macos::Gpu` (Metal + VideoToolbox), shaders MSL compilés via
diff --git a/technical-documentation/architecture/native-compositor.md b/technical-documentation/architecture/native-compositor.md
index 591fa15a2..1de664dfe 100644
--- a/technical-documentation/architecture/native-compositor.md
+++ b/technical-documentation/architecture/native-compositor.md
@@ -37,7 +37,7 @@ and without that flag the runtime corruption is silent.
| [`crates/compositor/src/text_anim.rs`](../../crates/compositor/src/text_anim.rs) | text-annotation appearance animations (port of the TS animation curves, in fractions of the output short side) |
| [`crates/compositor/src/config.rs`](../../crates/compositor/src/config.rs) | cumulative bench configs C0..C8 (each adds one layer: composite, rounded corners, shadow, background blur, zoom, layout animation, cursor, motion blur) |
| [`crates/compositor/src/live.rs`](../../crates/compositor/src/live.rs) | off-screen view: `Player` + `Compositor::compose_frame` → RGBA8 staging texture, pulled by the napi addon |
-| [`crates/compositor/src/shaders.hlsl`](../../crates/compositor/src/shaders.hlsl) | all GPU effects (modes 0/1/5/8/9/10/12 — see pipeline below), compiled at runtime via Fxc |
+| [`crates/compositor/src/shaders.hlsl`](../../crates/compositor/src/shaders.hlsl) | all GPU effects (modes 0/1/5/8/9/10/12 — see pipeline below), compiled at build time via Fxc (`build.rs`) and embedded as bytecode |
Six of those modules exist twice, once per platform, and `lib.rs` cfg-re-exports the pair
under one name — so `crate::d3d`, `crate::compositor`, `crate::pipeline` and `crate::text`