Fix alpha blending, entry points, and doc comments (PR review)

Address all 5 Copilot review comments from PR #223:

- Switch entire UI pipeline and compositor to premultiplied-alpha
  blending. The fragment shader now premultiplies RGB by final alpha
  before output, and both the UI pipeline and compositor use
  PREMULTIPLIED_ALPHA_BLENDING. This fixes edge darkening on borders
  and correct compositing of MSAA-resolved overlay textures.

- Fix border coverage in the fragment shader: compute straight-alpha
  weighted blend of border and fill colors, then premultiply at the
  end, avoiding the previous double-application of alpha at AA edges.

- Use explicit entry points (Some(linkage.entry_point)) in the UI
  render pipeline for consistency with the rest of the codebase.

- Update clip_rect doc to note it is reserved for future use (not
  currently enforced by the shader or renderer).

- Fix ui_vertex doc comment to only mention Path elements reading
  from the slab (TextGlyph uses the standard quad generation path).

Author: schell

crates/renderling-ui/src/renderer.rs

@@ -2299,7 +2299,7 @@ impl UiRenderer {
             layout: Some(&pipeline_layout),
             vertex: wgpu::VertexState {
                 module: &vertex_linkage.module,
-                entry_point: None,
+                entry_point: Some(vertex_linkage.entry_point),
                 compilation_options: wgpu::PipelineCompilationOptions::default(),
                 buffers: &[],
             },
@@ -2320,11 +2320,11 @@ impl UiRenderer {
             },
             fragment: Some(wgpu::FragmentState {
                 module: &fragment_linkage.module,
-                entry_point: None,
+                entry_point: Some(fragment_linkage.entry_point),
                 compilation_options: wgpu::PipelineCompilationOptions::default(),
                 targets: &[Some(wgpu::ColorTargetState {
                     format,
-                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                    blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),
                     write_mask: wgpu::ColorWrites::ALL,
                 })],
             }),

crates/renderling/shaders/ui_slab-shader-ui_fragment.spv

@@ -88,7 +88,7 @@ impl Compositor {
                 compilation_options: wgpu::PipelineCompilationOptions::default(),
                 targets: &[Some(wgpu::ColorTargetState {
                     format,
-                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                    blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),
                     write_mask: wgpu::ColorWrites::ALL,
                 })],
             }),

crates/renderling/src/compositor/cpu.rs

@@ -164,8 +164,8 @@ pub struct UiDrawCallDescriptor {
     /// Set to `Id::NONE` when unused.
     pub atlas_descriptor_id: Id<AtlasDescriptor>,
     /// Scissor/clip rectangle (x, y, width, height).
-    /// Elements outside this rect are clipped. Set to (0,0, viewport_w,
-    /// viewport_h) for no clipping.
+    /// Reserved for future use — not currently enforced by the shader
+    /// or renderer. Set to (0, 0, viewport_w, viewport_h) by default.
     pub clip_rect: Vec4,
     /// Element opacity (0.0 = fully transparent, 1.0 = fully opaque).
     /// Multiplied with the final alpha.

crates/renderling/src/ui_slab/mod.rs

@@ -4,7 +4,7 @@
 //! crate's `UiRenderer`.
 
 use crabslab::{Id, Slab, SlabItem};
-use glam::{Vec2, Vec4};
+use glam::{Vec2, Vec4, Vec4Swizzles};
 use spirv_std::{image::Image2dArray, spirv, Sampler};
 
 use super::{GradientType, UiDrawCallDescriptor, UiElementType, UiVertex, UiViewport};
@@ -95,8 +95,8 @@ fn eval_gradient(
 /// size, reading from the slab. The vertex index (0..5) selects which
 /// corner of the quad.
 ///
-/// For Path and TextGlyph elements, the vertex data is read directly
-/// from the slab (pre-tessellated vertices).
+/// For Path elements, the vertex data is read directly from the slab
+/// (pre-tessellated vertices).
 #[spirv(vertex)]
 pub fn ui_vertex(
     #[spirv(vertex_index)] vertex_index: u32,
@@ -254,11 +254,21 @@ pub fn ui_fragment(
                 let inner_distance = distance + draw_call.border_width;
                 let border_alpha =
                     1.0 - crate::math::smoothstep(-aa_width, aa_width, inner_distance);
-                // Inside the border but outside the fill = border color.
-                let in_border = fill_alpha;
-                let in_fill = border_alpha;
-                color = draw_call.border_color * (in_border - in_fill) + fill * in_fill;
-                color.w = draw_call.border_color.w * (in_border - in_fill) + fill.w * in_fill;
+                // Coverage weights.
+                let border_weight = fill_alpha - border_alpha;
+                let fill_weight = border_alpha;
+                let total = fill_alpha;
+                // Straight-alpha RGB: weighted blend of border and fill.
+                if total > 0.0 {
+                    let rgb = (draw_call.border_color.xyz() * border_weight
+                        + fill.xyz() * fill_weight)
+                        / total;
+                    let a =
+                        (draw_call.border_color.w * border_weight + fill.w * fill_weight) / total;
+                    color = rgb.extend(a * total);
+                } else {
+                    color = Vec4::ZERO;
+                }
             } else {
                 color = fill;
                 color.w *= fill_alpha;
@@ -269,5 +279,8 @@ pub fn ui_fragment(
     // Apply element opacity.
     color.w *= draw_call.opacity;
 
+    // Premultiply RGB by final alpha for premultiplied-alpha blending.
+    color = (color.xyz() * color.w).extend(color.w);
+
     *frag_color = color;
 }