Skip to content

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

fix(compositor): keep the 3D models out of the D3D11 and Metal layer shaders

Etienne Lescot8caaa20dd356
diff --git a/crates/compositor/build.rs b/crates/compositor/build.rs
index 66f465153..c55d8ee38 100644
--- a/crates/compositor/build.rs
+++ b/crates/compositor/build.rs
@@ -191,7 +191,7 @@ fn main() {
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;
+ use windows::Win32::Graphics::Direct3D::{ID3DBlob, D3D_SHADER_MACRO};
fn blob_bytes(blob: &ID3DBlob) -> Vec<u8> {
unsafe {
@@ -203,17 +203,25 @@ fn compile_hlsl(out: &Path) {
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"),
+ // `ps_main` avec les modèles 3D : la variante que seuls ces calques utilisent (le haut de
+ // `shaders.hlsl`). La liste se termine par une entrée nulle.
+ let models = [
+ D3D_SHADER_MACRO { Name: PCSTR(b"LAYER_MODELS\0".as_ptr()), Definition: PCSTR(b"1\0".as_ptr()) },
+ D3D_SHADER_MACRO { Name: PCSTR::null(), Definition: PCSTR::null() },
+ ];
+ // Tous les points d'entrée que `Compositor::new_inner` instancie, avec leur profil, le nom du
+ // `.cso` qu'en lit `shader!` et leurs macros.
+ for (entry, profile, cso, defines) in [
+ ("vs_main", "vs_5_0", "vs_main", None),
+ ("ps_main", "ps_5_0", "ps_main", None),
+ ("ps_main", "ps_5_0", "ps_main_models", Some(models.as_ptr())),
+ ("vs_fs", "vs_5_0", "vs_fs", None),
+ ("ps_y", "ps_5_0", "ps_y", None),
+ ("ps_uv", "ps_5_0", "ps_uv", None),
+ ("ps_blur", "ps_5_0", "ps_blur", None),
+ ("ps_tex", "ps_5_0", "ps_tex", None),
+ ("ps_kawase_down", "ps_5_0", "ps_kawase_down", None),
+ ("ps_kawase_up", "ps_5_0", "ps_kawase_up", None),
] {
let (entry_z, profile_z) = (format!("{entry}\0"), format!("{profile}\0"));
let (mut code, mut errors): (Option<ID3DBlob>, Option<ID3DBlob>) = (None, None);
@@ -222,7 +230,7 @@ fn compile_hlsl(out: &Path) {
hlsl.as_ptr().cast(),
hlsl.len(),
PCSTR(b"shaders.hlsl\0".as_ptr()),
- None,
+ defines,
None,
PCSTR(entry_z.as_ptr()),
PCSTR(profile_z.as_ptr()),
@@ -234,9 +242,9 @@ fn compile_hlsl(out: &Path) {
};
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));
+ panic!("{SRC} : {cso} ne compile pas ({e})\n{}", String::from_utf8_lossy(&log));
}
- std::fs::write(out.join(format!("{entry}.cso")), blob_bytes(&code.unwrap())).expect(entry);
+ std::fs::write(out.join(format!("{cso}.cso")), blob_bytes(&code.unwrap())).expect(cso);
}
}
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index 64f048365..f659fdde0 100644
--- a/crates/compositor/src/compositor_macos.rs
+++ b/crates/compositor/src/compositor_macos.rs
@@ -318,6 +318,14 @@ pub struct Compositor {
pipeline_fs_tex: metal::RenderPipelineState,
/// `vs_main` + `ps_main` en additif : les échantillons de traînée du curseur.
pipeline_add: metal::RenderPipelineState,
+ /// `pipeline_main` et `pipeline_add` compilés AVEC les modèles 3D (`LAYER_MODELS`, cf.
+ /// l'en-tête de `shaders.metal`). Les deux autres ne les ont pas ; `draw_layer` bascule sur
+ /// ceux-ci le temps du draw d'un modèle (`LayerCB::needs_models`).
+ pipeline_main_models: metal::RenderPipelineState,
+ pipeline_add_models: metal::RenderPipelineState,
+ /// La passe en cours a été ouverte sur `pipeline_add` (cf. `begin_pass`) : dit à
+ /// `draw_layer` laquelle des deux variantes « modèles » prendre.
+ layer_add: std::cell::Cell<bool>,
/// Buffer d'accumulation ISOLÉ (transparent) pour la traînée. Accumuler directement sur
/// le RT reviendrait à AJOUTER du blanc à ce qui est déjà dessous : sur un fond clair,
/// le curseur disparaît. Même raisonnement que côté D3D11.
@@ -539,6 +547,12 @@ enum Blend {
Add,
}
+/// `shaders.metal` avec les modèles 3D : la source dont seuls les pipelines de ces calques sont
+/// tirés (cf. son en-tête).
+fn msl_source_with_models() -> String {
+ format!("#define LAYER_MODELS 1\n{}", include_str!("shaders.metal"))
+}
+
/// Un pipeline state à une seule pièce jointe couleur.
fn make_pipeline(
device: &metal::Device,
@@ -663,6 +677,25 @@ impl Compositor {
metal::MTLPixelFormat::RGBA8Unorm,
Blend::Add,
)?;
+ let library_models = device
+ .new_library_with_source(&msl_source_with_models(), &metal::CompileOptions::new())
+ .map_err(|e| anyhow!("MTLDevice::new_library_with_source (modèles) a échoué : {e}"))?;
+ let pipeline_main_models = make_pipeline(
+ device,
+ &library_models,
+ "vs_main",
+ "ps_main",
+ metal::MTLPixelFormat::RGBA8Unorm,
+ Blend::Over,
+ )?;
+ let pipeline_add_models = make_pipeline(
+ device,
+ &library_models,
+ "vs_main",
+ "ps_main",
+ metal::MTLPixelFormat::RGBA8Unorm,
+ Blend::Add,
+ )?;
let pipeline_kdown = make_pipeline(
device, &library, "vs_fs", "ps_kawase_down",
metal::MTLPixelFormat::RGBA8Unorm, Blend::Replace,
@@ -706,6 +739,9 @@ impl Compositor {
pipeline_fs_uv,
pipeline_fs_tex,
pipeline_add,
+ pipeline_main_models,
+ pipeline_add_models,
+ layer_add: std::cell::Cell::new(false),
accum,
trail,
blur_half,
@@ -912,7 +948,20 @@ impl Compositor {
enc.set_fragment_texture(0, Some(y));
enc.set_fragment_texture(1, Some(uv));
}
- enc.draw_primitives(metal::MTLPrimitiveType::TriangleStrip, 0, 4);
+ // Un modèle 3D passe, le temps de son draw, par la variante « modèles » du pipeline de la
+ // passe, la seule à le compiler ; le pipeline plat reprend ensuite la main.
+ if cb.needs_models() {
+ let (models, flat) = if self.layer_add.get() {
+ (&self.pipeline_add_models, &self.pipeline_add)
+ } else {
+ (&self.pipeline_main_models, &self.pipeline_main)
+ };
+ enc.set_render_pipeline_state(models);
+ enc.draw_primitives(metal::MTLPrimitiveType::TriangleStrip, 0, 4);
+ enc.set_render_pipeline_state(flat);
+ } else {
+ enc.draw_primitives(metal::MTLPrimitiveType::TriangleStrip, 0, 4);
+ }
}
/// Quad de couleur pleine / gradient / ombre — tout ce qui n'échantillonne pas la vidéo.
@@ -2072,6 +2121,8 @@ impl Compositor {
ca.set_store_action(metal::MTLStoreAction::Store);
let enc = cmd.new_render_command_encoder(&desc);
enc.set_render_pipeline_state(pipeline);
+ // La famille du pipeline de calque de cette passe, pour `draw_layer`.
+ self.layer_add.set(std::ptr::eq(pipeline, &self.pipeline_add));
Ok(enc)
}
@@ -4306,6 +4357,12 @@ mod tests {
&metal::CompileOptions::new(),
)
.expect("shaders.metal doit compiler");
+ // La variante des modèles 3D (`LAYER_MODELS`) : la seule à compiler leurs branches.
+ device
+ .new_library_with_source(&super::msl_source_with_models(), &metal::CompileOptions::new())
+ .expect("shaders.metal doit compiler avec LAYER_MODELS")
+ .get_function("ps_main", None)
+ .expect("ps_main absent de la variante LAYER_MODELS");
for name in [
"vs_main",
"vs_fs",
diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs
index 1875d4a34..8b7b820c1 100644
--- a/crates/compositor/src/compositor_windows.rs
+++ b/crates/compositor/src/compositor_windows.rs
@@ -93,7 +93,10 @@ pub struct Compositor {
rt_srv: ID3D11ShaderResourceView,
staging: ID3D11Texture2D,
vs: ID3D11VertexShader,
+ /// Le pixel shader des calques, SANS les modèles 3D (modes 15 à 17) : ils passent par
+ /// `ps_models`, et `draw_layer` choisit d'après le mode (le haut de `shaders.hlsl`).
ps: ID3D11PixelShader,
+ ps_models: ID3D11PixelShader,
vs_fs: ID3D11VertexShader,
ps_y: ID3D11PixelShader,
ps_uv: ID3D11PixelShader,
@@ -604,6 +607,8 @@ impl Compositor {
dev.CreateVertexShader(shader!("vs_main"), None, Some(&mut vs))?;
let mut ps: Option<ID3D11PixelShader> = None;
dev.CreatePixelShader(shader!("ps_main"), None, Some(&mut ps))?;
+ let mut ps_models: Option<ID3D11PixelShader> = None;
+ dev.CreatePixelShader(shader!("ps_main_models"), None, Some(&mut ps_models))?;
// shaders RGB->NV12
let mut vs_fs: Option<ID3D11VertexShader> = None;
@@ -694,6 +699,7 @@ impl Compositor {
staging,
vs: vs.unwrap(),
ps: ps.unwrap(),
+ ps_models: ps_models.unwrap(),
vs_fs: vs_fs.unwrap(),
ps_y: ps_y.unwrap(),
ps_uv: ps_uv.unwrap(),
@@ -1090,6 +1096,15 @@ impl Compositor {
self.ctx.PSSetConstantBuffers(0, Some(&[Some(self.cbuf.clone())]));
}
+ /// Dessine le quad d'un calque, ses ressources déjà liées. Le pixel shader suit son mode :
+ /// `ps_models` pour un modèle 3D (`LayerCB::needs_models`), `ps` pour tout le reste, qui ne
+ /// paie pas ainsi les registres de ces modèles.
+ unsafe fn draw_layer(&self, cb: &LayerCB) {
+ self.upload_cb(cb);
+ self.ctx.PSSetShader(if cb.needs_models() { &self.ps_models } else { &self.ps }, None);
+ self.ctx.Draw(4, 0);
+ }
+
/// Calque vidéo NV12.
pub unsafe fn draw_video(
&self,
@@ -1097,16 +1112,14 @@ impl Compositor {
srv_y: &ID3D11ShaderResourceView,
srv_uv: &ID3D11ShaderResourceView,
) {
- self.upload_cb(cb);
self.ctx
.PSSetShaderResources(0, Some(&[Some(srv_y.clone()), Some(srv_uv.clone())]));
- self.ctx.Draw(4, 0);
+ self.draw_layer(cb);
}
/// Calque couleur pleine (fond).
pub unsafe fn draw_solid(&self, cb: &LayerCB) {
- self.upload_cb(cb);
- self.ctx.Draw(4, 0);
+ self.draw_layer(cb);
}
/// Fond wallpaper image (cover-fit). `path` = chemin absolu (résolu côté app). Décodé et
@@ -1200,7 +1213,8 @@ impl Compositor {
(0.0, (1.0 - vis) * 0.5, 1.0, 1.0 - (1.0 - vis) * 0.5)
};
let (anim, mb) = crate::frame_geometry::wallpaper_motion_slots(motion, programme_t, ao);
- self.upload_cb(&LayerCB {
+ self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
+ self.draw_layer(&LayerCB {
dst,
src: [u0, v0, u1, v1],
quad_px,
@@ -1210,8 +1224,6 @@ impl Compositor {
mb,
..Default::default()
});
- self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
- self.ctx.Draw(4, 0);
Ok(())
}
@@ -1767,10 +1779,9 @@ impl Compositor {
if let Some(cb) = crate::frame_geometry::cursor_model_cb(
placement, size_px, pose, shape, a, clip,
) {
- self.upload_cb(&cb);
self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
self.ctx.PSSetShaderResources(4, Some(&[Some(sdf)]));
- self.ctx.Draw(4, 0);
+ self.draw_layer(&cb);
self.ctx.PSSetShaderResources(4, Some(&[None]));
}
return Ok(());
@@ -1788,9 +1799,8 @@ impl Compositor {
clip,
[self.rw(), self.rh()],
);
- self.upload_cb(&cb);
self.ctx.PSSetShaderResources(2, Some(&[Some(srv)]));
- self.ctx.Draw(4, 0);
+ self.draw_layer(&cb);
Ok(())
}
diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlsl
index 37614e23d..1ffb5e1e9 100644
--- a/crates/compositor/src/shaders.hlsl
+++ b/crates/compositor/src/shaders.hlsl
@@ -1,5 +1,12 @@
// Compositeur — un draw par calque (quad). NV12->RGB maison (E1), coins arrondis SDF (E2).
// Tout écrit depuis les maths (§7), rien repris de l'ancien paradigme.
+//
+// `ps_main` est compilé DEUX fois (`build.rs`) : sans `LAYER_MODELS` pour tous les calques, et
+// avec, en `ps_main_models`, pour les seuls modèles 3D (modes 15 à 17, `LayerCB::needs_models`).
+// Un pixel shader alloue à chaque draw les registres de sa branche la plus lourde, et ce sont
+// ces modèles ray-tracés : le même shader les portait pour le fond, l'ombre et la vidéo, qui
+// couvrent toute la sortie. Mesuré sur la version WGSL (RADV) : 168 VGPR, 6 vagues par SIMD au
+// lieu de 32, et un export Linux deux fois plus lent ; sans eux, 48.
cbuffer Layer : register(b0)
{
@@ -3516,6 +3523,7 @@ float4 ps_main(VSOut i) : SV_Target
return acc / max(n, 1.0);
}
+#ifdef LAYER_MODELS
// mode 17 : CADRE D'APPAREIL MODELÉ (cf. `device_frame`). Testé en premier, comme le 16.
if (mode > 16.5)
{
@@ -3539,6 +3547,14 @@ float4 ps_main(VSOut i) : SV_Target
}
return cursor_model(i.local);
}
+#else
+ // Les modèles 3D n'existent que dans `ps_main_models` ; un draw qui les enverrait ici ne
+ // peint rien plutôt qu'une ombre faite de leurs emplacements.
+ if (mode > 14.5)
+ {
+ return float4(0.0, 0.0, 0.0, 0.0);
+ }
+#endif
// mode 14 : CADRE DE FENÊTRE autour de l'écran (barre de titre, trois pastilles, filet),
// dessiné SOUS lui. Testé avant le mode 13, dont la branche n'a pas de borne haute.
diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metal
index 6456c3ff7..60654c0da 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -33,6 +33,12 @@
// `compositor_macos::tests::every_shader_entry_point_compiles` le compile sur le device
// système au `cargo test`, pour qu'une faute de syntaxe MSL ne se découvre pas à
// l'ouverture de l'éditeur chez un utilisateur.
+//
+// Il est compilé DEUX fois (`compositor_macos.rs::new_sized`) : tel quel pour tous les calques,
+// et avec `LAYER_MODELS` défini pour les seuls modèles 3D (modes 15 à 17,
+// `LayerCB::needs_models`). Un shader alloue à chaque draw les registres de sa branche la plus
+// lourde, et ce sont ces modèles ray-tracés : le même `ps_main` les portait pour le fond,
+// l'ombre et la vidéo, qui couvrent toute la sortie (cf. le haut de `shaders.hlsl`).
#include <metal_stdlib>
using namespace metal;
@@ -3289,6 +3295,7 @@ fragment float4 ps_main(VSOut i [[stage_in]],
return acc / max(n, 1.0);
}
+#ifdef LAYER_MODELS
// mode 17 : CADRE D'APPAREIL MODELÉ (`device_frame`). Testé en premier, comme le 16.
if (layer.mode > 16.5)
{
@@ -3312,6 +3319,14 @@ fragment float4 ps_main(VSOut i [[stage_in]],
}
return cursor_model(i.local, layer, texSdf, texImg, texDof);
}
+#else
+ // Les modèles 3D n'existent que dans la variante `LAYER_MODELS` ; un draw qui les enverrait
+ // ici ne peint rien plutôt qu'une ombre faite de leurs emplacements.
+ if (layer.mode > 14.5)
+ {
+ return float4(0.0, 0.0, 0.0, 0.0);
+ }
+#endif
// mode 14 : CADRE DE FENÊTRE autour de l'écran, dessiné SOUS lui. Cf. commentaires HLSL.
// Testé avant le mode 13, dont la branche n'a pas de borne haute.