monolith

public

Star0

Fork 0

Watch0

199 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `c0caa658decf`

tarball

atagen <boss@atagen.co>2026-10-19 07:56 UTC

5 files changed+59-9

render-vk: skip blending for draws that cover what is under them

Every pipeline blended, including X-format textures at full alpha and opaque solid fills, which cost a destination read for nothing. Pipelines::get takes an opaque flag and frames set it for Texture draws of formats without alpha and for Solid draws at alpha one, and only when no rounded clip can lower the coverage.

Modified file: crates/render-vk/src/frame.rs+6 additions@@ -16,6 +16,7 @@ pub(crate) enum Op {
     },
     Draw {
         kind: Kind,
+        opaque: bool,
         texture: Option<VulkanTexture>,
         push: Push,
         scissors: Vec<vk::Rect2D>,
@@ -192,6 +193,10 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
         };
         self.ops.push(Op::Draw {
             kind,
+            opaque: kind == Kind::Texture
+                && alpha >= 1.0
+                && self.clip.is_none()
+                && texture.0.opaque(),
             texture: Some(texture.clone()),
             push,
             scissors,
@@ -253,6 +258,7 @@ impl Frame for VulkanFrame<'_, '_> {
         };
         self.ops.push(Op::Draw {
             kind: Kind::Solid,
+            opaque: color.a() >= 1.0 && self.clip.is_none(),
             texture: None,
             push,
             scissors,

Modified file: crates/render-vk/src/image.rs+5 additions@@ -167,6 +167,11 @@ impl ImageInner {
         Ok(Arc::new(inner))
     }
 
+    /// Whether sampling the image always gives alpha one.
+    pub fn opaque(&self) -> bool {
+        vk_format(self.fourcc).is_some_and(|f| f.opaque)
+    }
+
     pub fn layout(&self) -> vk::ImageLayout {
         *self.layout.lock().unwrap_or_else(|e| e.into_inner())
     }

Modified file: crates/render-vk/src/pipeline.rs+21 additions−8 deletions@@ -47,7 +47,7 @@ pub(crate) struct Pipelines {
     solid: vk::ShaderModule,
     texture: vk::ShaderModule,
     effect: vk::ShaderModule,
-    cache: HashMap<(vk::Format, Kind), vk::Pipeline>,
+    cache: HashMap<(vk::Format, Kind, bool), vk::Pipeline>,
     vk_cache: vk::PipelineCache,
     cache_path: Option<PathBuf>,
     loaded_len: usize,
@@ -135,9 +135,15 @@ impl Pipelines {
             let Some(format) = vk_format(fourcc) else {
                 continue;
             };
-            for kind in [Kind::Solid, Kind::Texture, Kind::Effect] {
-                if let Err(e) = self.get(format.format, kind) {
-                    tracing::warn!(?kind, "cannot warm a pipeline: {e}");
+            for (kind, opaque) in [
+                (Kind::Solid, false),
+                (Kind::Solid, true),
+                (Kind::Texture, false),
+                (Kind::Texture, true),
+                (Kind::Effect, false),
+            ] {
+                if let Err(e) = self.get(format.format, kind, opaque) {
+                    tracing::warn!(?kind, opaque, "cannot warm a pipeline: {e}");
                     return;
                 }
             }
@@ -180,8 +186,15 @@ impl Pipelines {
         }
     }
 
-    pub fn get(&mut self, format: vk::Format, kind: Kind) -> Result<vk::Pipeline, Error> {
-        if let Some(&p) = self.cache.get(&(format, kind)) {
+    /// The pipeline for `kind` into `format`. An `opaque` one replaces the
+    /// destination instead of blending, for draws known to cover it.
+    pub fn get(
+        &mut self,
+        format: vk::Format,
+        kind: Kind,
+        opaque: bool,
+    ) -> Result<vk::Pipeline, Error> {
+        if let Some(&p) = self.cache.get(&(format, kind, opaque)) {
             return Ok(p);
         }
         let d = &self.shared.device.device;
@@ -213,7 +226,7 @@ impl Pipelines {
         let multisample = vk::PipelineMultisampleStateCreateInfo::default()
             .rasterization_samples(vk::SampleCountFlags::TYPE_1);
         let attachments = [vk::PipelineColorBlendAttachmentState::default()
-            .blend_enable(true)
+            .blend_enable(!opaque)
             .src_color_blend_factor(vk::BlendFactor::ONE)
             .dst_color_blend_factor(vk::BlendFactor::ONE_MINUS_SRC_ALPHA)
             .color_blend_op(vk::BlendOp::ADD)
@@ -240,7 +253,7 @@ impl Pipelines {
             .push_next(&mut rendering);
         let pipeline = unsafe { d.create_graphics_pipelines(self.vk_cache, &[info], None) }
             .map_err(|(_, e)| e)?[0];
-        self.cache.insert((format, kind), pipeline);
+        self.cache.insert((format, kind, opaque), pipeline);
         Ok(pipeline)
     }
 }

Modified file: crates/render-vk/src/renderer/mod.rs+3 additions−1 deletions@@ -429,7 +429,9 @@ impl VulkanRenderer {
         let mut pipelines = Vec::with_capacity(ops.len());
         for op in &ops {
             pipelines.push(match op {
-                Op::Draw { kind, .. } => Some(self.pipelines.get(image.format, *kind)?),
+                Op::Draw { kind, opaque, .. } => {
+                    Some(self.pipelines.get(image.format, *kind, *opaque)?)
+                }
                 Op::Clear { .. } => None,
             });
         }

Modified file: crates/render-vk/tests/golden.rs+24 additions@@ -275,3 +275,27 @@ fn queued_uploads_to_one_texture_land_in_order() {
     });
     assert_eq!(at(&s.pixels(), 32, 32), RED);
 }
+
+#[test]
+fn opaque_format_texture_replaces_what_is_under_it() {
+    let mut s = Scene::new();
+    let bytes = [0u8, 255, 0, 0];
+    let tex = s
+        .renderer
+        .import_memory(&bytes, Fourcc::Xbgr8888, (1, 1).into(), false)
+        .unwrap();
+    s.draw(Transform::Normal, |f| {
+        f.clear(rgba(RED), &[full()]).unwrap();
+        f.render_texture_from_to(
+            &tex,
+            Rectangle::from_size((1.0, 1.0).into()),
+            full(),
+            &[full()],
+            &[],
+            Transform::Normal,
+            1.0,
+        )
+        .unwrap();
+    });
+    assert_eq!(at(&s.pixels(), 32, 32), GREEN);
+}

monolith

Commit c0caa658decf

Commit `c0caa658decf`