xgpui-shader 0.5.0

Shader and paint extension for xgpui with gradients, brushes, and portable WGSL shaders
Documentation
// PATCH_COEFFICIENTS is a bicubic power basis in row-major (v,u) order.
struct PatchFrame { position: vec2<f32>, du: vec2<f32>, dv: vec2<f32> }
fn patch_cell(uv:vec2<f32>) -> vec2<u32> {
    let count=vec2(f32(PATCH_COLUMNS),f32(PATCH_ROWS));
    return vec2<u32>(clamp(floor(uv*count),vec2(0.),count-vec2(1.)));
}
fn patch_frame(uv: vec2<f32>) -> PatchFrame {
    let count=vec2(f32(PATCH_COLUMNS),f32(PATCH_ROWS));
    let cell=patch_cell(uv);
    let local=uv*count-vec2<f32>(cell);
    let offset=(cell.y*PATCH_COLUMNS+cell.x)*16u;
    var rows: array<vec2<f32>,4>;
    var derivatives: array<vec2<f32>,4>;
    for (var j = 0u; j < 4u; j += 1u) {
        let a = PATCH_COEFFICIENTS[offset+j*4u];
        let b = PATCH_COEFFICIENTS[offset+j*4u+1u];
        let c = PATCH_COEFFICIENTS[offset+j*4u+2u];
        let d = PATCH_COEFFICIENTS[offset+j*4u+3u];
        rows[j] = ((d*local.x+c)*local.x+b)*local.x+a;
        derivatives[j] = (3.*d*local.x+2.*c)*local.x+b;
    }
    return PatchFrame(
        ((rows[3]*local.y+rows[2])*local.y+rows[1])*local.y+rows[0],
        (((derivatives[3]*local.y+derivatives[2])*local.y+derivatives[1])*local.y+derivatives[0])*count.x,
        ((3.*rows[3]*local.y+2.*rows[2])*local.y+rows[1])*count.y);
}
fn mesh_color(input: ShaderInput, p: Parameters) -> vec4<f32> {
    let receiver = input.uv;
    var uv = clamp(receiver,vec2(0.),vec2(1.));
    // The host certifies ||I-J||_infinity <= 0.5 over the entire patch.
    // Projected fixed-point iterations give a close initial inverse estimate.
    for (var i = 0u; i < 6u; i += 1u) {
        uv = clamp(uv+receiver-patch_frame(uv).position,vec2(0.),vec2(1.));
    }
    // Allow a small exterior inverse for antialiased patch edges. Large exterior
    // receivers stay bounded and fail the residual/parameter checks below.
    for (var i = 0u; i < 6u; i += 1u) {
        let frame = patch_frame(uv);
        let delta = frame.position-receiver;
        let determinant = frame.du.x*frame.dv.y-frame.du.y*frame.dv.x;
        if (determinant <= 0.0001) { return vec4(0.); }
        let step = vec2(delta.x*frame.dv.y-delta.y*frame.dv.x,
                        frame.du.x*delta.y-frame.du.y*delta.x)/determinant;
        uv = clamp(uv-step,vec2(-0.25),vec2(1.25));
    }
    let frame = patch_frame(uv);
    if (any(abs(frame.position-receiver) > vec2(0.00001))) { return vec4(0.); }
    let determinant = frame.du.x*frame.dv.y-frame.du.y*frame.dv.x;
    if (determinant <= 0.0001) { return vec4(0.); }
    let device_size = input.size*input.scale_factor;
    let du_pixel = length(vec2(frame.dv.y,-frame.dv.x)/determinant/device_size);
    let dv_pixel = length(vec2(-frame.du.y,frame.du.x)/determinant/device_size);
    let edge = min(min(uv.x,1.-uv.x)/max(du_pixel,0.0000001),
                   min(uv.y,1.-uv.y)/max(dv_pixel,0.0000001));
    let coverage = clamp(0.5+edge,0.,1.);
    let global=clamp(uv,vec2(0.),vec2(1.));
    let cell=patch_cell(global);
    let t=global*vec2(f32(PATCH_COLUMNS),f32(PATCH_ROWS))-vec2<f32>(cell);
    let color_offset=(cell.y*PATCH_COLUMNS+cell.x)*4u;
    let h = t*t*(3.-2.*t);
    let top = mix(associated(PATCH_COLORS[color_offset+0u]),associated(PATCH_COLORS[color_offset+1u]),h.x);
    let bottom = mix(associated(PATCH_COLORS[color_offset+2u]),associated(PATCH_COLORS[color_offset+3u]),h.x);
    let color = straight(mix(top,bottom,h.y));
    return vec4(color.rgb,color.a*coverage);
}