feat: wasm compositor

Made-with: Cursor

1 files changed, 142 insertions, 0 deletions

diff --git a/rust/crates/compositor/src/shaders/blend.wgsl b/rust/crates/compositor/src/shaders/blend.wgsl
new file mode 100644
index 00000000..9cc0e120
--- /dev/null
+++ b/rust/crates/compositor/src/shaders/blend.wgsl
@@ -0,0 +1,142 @@
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+    @location(0) tex_coord: vec2f,
+}
+
+struct BlendUniforms {
+    blend_mode: u32,
+    _pad0: u32,
+    _pad1: u32,
+    _pad2: u32,
+}
+
+@group(0) @binding(0) var base_texture: texture_2d<f32>;
+@group(0) @binding(1) var base_sampler: sampler;
+@group(1) @binding(0) var layer_texture: texture_2d<f32>;
+@group(1) @binding(1) var layer_sampler: sampler;
+@group(2) @binding(0) var<uniform> uniforms: BlendUniforms;
+
+fn clamp01(color: vec3f) -> vec3f {
+    return clamp(color, vec3f(0.0), vec3f(1.0));
+}
+
+fn lum(c: vec3f) -> f32 {
+    return dot(c, vec3f(0.3, 0.59, 0.11));
+}
+
+fn sat(c: vec3f) -> f32 {
+    return max(max(c.r, c.g), c.b) - min(min(c.r, c.g), c.b);
+}
+
+fn clip_color(c: vec3f) -> vec3f {
+    var result = c;
+    let l = lum(result);
+    let n = min(min(result.r, result.g), result.b);
+    let x = max(max(result.r, result.g), result.b);
+    if (n < 0.0) {
+        result = l + ((result - l) * l) / (l - n);
+    }
+    if (x > 1.0) {
+        result = l + ((result - l) * (1.0 - l)) / (x - l);
+    }
+    return result;
+}
+
+fn set_lum(c: vec3f, l: f32) -> vec3f {
+    return clip_color(c + (l - lum(c)));
+}
+
+fn set_sat(color: vec3f, target_sat: f32) -> vec3f {
+    var result = color;
+    let max_value = max(max(result.r, result.g), result.b);
+    let min_value = min(min(result.r, result.g), result.b);
+    if (max_value <= min_value) {
+        return vec3f(0.0);
+    }
+    let scale = target_sat / (max_value - min_value);
+    result = (result - vec3f(min_value)) * scale;
+    return result;
+}
+
+fn hard_light(base: vec3f, layer: vec3f) -> vec3f {
+    let low = 2.0 * base * layer;
+    let high = 1.0 - 2.0 * (1.0 - base) * (1.0 - layer);
+    return select(low, high, layer >= vec3f(0.5));
+}
+
+fn soft_light_channel(base: f32, layer: f32) -> f32 {
+    if (layer <= 0.5) {
+        return base - (1.0 - 2.0 * layer) * base * (1.0 - base);
+    }
+
+    let d = select(
+        ((16.0 * base - 12.0) * base + 4.0) * base,
+        sqrt(base),
+        base > 0.25,
+    );
+    return base + (2.0 * layer - 1.0) * (d - base);
+}
+
+fn soft_light(base: vec3f, layer: vec3f) -> vec3f {
+    return vec3f(
+        soft_light_channel(base.r, layer.r),
+        soft_light_channel(base.g, layer.g),
+        soft_light_channel(base.b, layer.b),
+    );
+}
+
+fn color_dodge(base: vec3f, layer: vec3f) -> vec3f {
+    return select(
+        min(vec3f(1.0), base / max(vec3f(0.0001), vec3f(1.0) - layer)),
+        vec3f(1.0),
+        layer >= vec3f(1.0),
+    );
+}
+
+fn color_burn(base: vec3f, layer: vec3f) -> vec3f {
+    return select(
+        vec3f(1.0) - min(vec3f(1.0), (vec3f(1.0) - base) / max(vec3f(0.0001), layer)),
+        vec3f(0.0),
+        layer <= vec3f(0.0),
+    );
+}
+
+fn blend_rgb(base: vec3f, layer: vec3f, mode: u32) -> vec3f {
+    switch mode {
+        case 1u { return min(base, layer); }
+        case 2u { return base * layer; }
+        case 3u { return color_burn(base, layer); }
+        case 4u { return max(base, layer); }
+        case 5u { return 1.0 - (1.0 - base) * (1.0 - layer); }
+        case 6u { return min(vec3f(1.0), base + layer); }
+        case 7u { return color_dodge(base, layer); }
+        case 8u { return select(
+            2.0 * base * layer,
+            1.0 - 2.0 * (1.0 - base) * (1.0 - layer),
+            base >= vec3f(0.5),
+        ); }
+        case 9u { return soft_light(base, layer); }
+        case 10u { return hard_light(base, layer); }
+        case 11u { return abs(base - layer); }
+        case 12u { return base + layer - 2.0 * base * layer; }
+        case 13u { return set_lum(set_sat(layer, sat(base)), lum(base)); }
+        case 14u { return set_lum(set_sat(base, sat(layer)), lum(base)); }
+        case 15u { return set_lum(layer, lum(base)); }
+        case 16u { return set_lum(base, lum(layer)); }
+        default { return layer; }
+    }
+}
+
+@fragment
+fn fragment_main(input: VertexOutput) -> @location(0) vec4f {
+    let base = textureSample(base_texture, base_sampler, input.tex_coord);
+    let layer = textureSample(layer_texture, layer_sampler, input.tex_coord);
+
+    let blend_rgb_value = blend_rgb(base.rgb, layer.rgb, uniforms.blend_mode);
+    let out_alpha = layer.a + base.a * (1.0 - layer.a);
+    let out_rgb =
+        ((1.0 - layer.a) * base.rgb) +
+        (layer.a * ((1.0 - base.a) * layer.rgb + base.a * blend_rgb_value));
+
+    return vec4f(clamp01(out_rgb), out_alpha);
+}