Skip to content

Free open-source image editor for the browser

3.4 KB
Raw Blame
import { patchCoverage } from "./coverage.wgsl";
struct Params {
  origin: vec2f,
  extent: vec2f,
  dimensions: vec2f,
  offset: vec2f,
  grid: vec2f,
  mode: u32,
  feather: f32,
  opacity: f32,
  // The patch's coverage covers only the tiles its stroke reaches, from this corner.
  coverageOrigin: vec2f,
  coverageSize: vec2f,
}
@group(0) @binding(0) var source: texture_2d<f32>;
@group(0) @binding(1) var coverage: texture_2d<f32>;
@group(0) @binding(2) var previous: texture_2d<f32>;
@group(0) @binding(3) var linearSampler: sampler;
@group(0) @binding(4) var<uniform> params: Params;

fn color(p: vec2f) -> vec4f {
  return textureSampleLevel(source, linearSampler, p / params.dimensions, 0.0);
}
fn mask(p: vec2f) -> f32 {
  return textureSampleLevel(coverage, linearSampler, (p - params.coverageOrigin) / params.coverageSize, 0.0).r;
}
fn difference(p: vec2f) -> vec3f {
  // A smooth log gain matches color without subtracting bright-boundary differences
  // from dark donor texture, which would clip it into black islands.
  return log(max(color(p).rgb, vec3f(0.0)) + 0.0001) - log(max(color(p + params.offset).rgb, vec3f(0.0)) + 0.0001);
}
fn correction(uv: vec2f) -> vec3f {
  let p = params.origin + uv * params.extent;
  if (any(uv < vec2f(0.0)) || any(uv > vec2f(1.0)) || mask(p) < 0.001) {
    return difference(p);
  }
  return textureSampleLevel(previous, linearSampler, uv, 0.0).rgb;
}

@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {
  let uv = position.xy / params.grid;
  if (params.mode == 3u || params.mode == 4u) {
    let p = uv * params.dimensions;
    let original = color(p);
    if (any(p < params.origin) || any(p > params.origin + params.extent)) {
      return original;
    }
    let amount = patchCoverage(coverage, linearSampler, p - params.coverageOrigin, params.coverageSize, params.feather) * params.opacity;
    let donor = p + params.offset;
    if (amount == 0.0 || any(donor < vec2f(0.5)) || any(donor > params.dimensions - 0.5)) {
      return original;
    }
    if (params.mode == 4u) {
      return vec4f(mix(original.rgb, color(donor).rgb, amount), original.a);
    }
    let donorColor = max(color(donor).rgb, vec3f(0.0));
    let delta = textureSampleLevel(previous, linearSampler, (p - params.origin) / params.extent, 0.0).rgb;
    // Bound the gain and damp chroma correction so a small dark channel cannot
    // produce the extreme saturation shifts of an unrestricted RGB ratio.
    let luminanceDelta = dot(delta, vec3f(0.2627, 0.6780, 0.0593));
    let safeDelta = clamp(vec3f(luminanceDelta) + (delta - vec3f(luminanceDelta)) * 0.95, vec3f(-0.35), vec3f(0.35));
    let healed = (donorColor + 0.0001) * exp(safeDelta) - 0.0001;
    return vec4f(mix(original.rgb, max(vec3f(0.0), healed), amount), original.a);
  }
  let p = params.origin + uv * params.extent;
  if (mask(p) < 0.001) {
    return vec4f(difference(p), 1.0);
  }
  if (params.mode == 0u) {
    return vec4f(0.0, 0.0, 0.0, 1.0);
  }
  if (params.mode == 1u) {
    return vec4f(correction(uv), 1.0);
  }
  let step = 1.0 / params.grid;
  let x = correction(uv + vec2f(step.x, 0.0)) + correction(uv - vec2f(step.x, 0.0));
  let y = correction(uv + vec2f(0.0, step.y)) + correction(uv - vec2f(0.0, step.y));
  // Non-square crops have unequal grid spacing in document pixels.
  let spacing = params.extent / params.grid;
  let weights = 1.0 / (spacing * spacing);
  return vec4f((x * weights.x + y * weights.y) / (2.0 * (weights.x + weights.y)), 1.0);
}