primal-barracuda 0.4.0

barraCuda — BARrier-free Rust Abstracted Cross-platform Unified Dimensional Algebra. Vendor-agnostic GPU compute via WGSL.
Documentation
// SPDX-License-Identifier: AGPL-3.0-or-later
// RandomAffine - Random affine transformations
//
// Applies random rotation, translation, scale, and shear

struct Params {
    channels: u32,
    height: u32,
    width: u32,
    a: f32,
    b: f32,
    c: f32,
    d: f32,
    e: f32,
    f: f32,
    cx: f32,
    cy: f32,
}

@group(0) @binding(0) var<storage, read> input: array<f64>;
@group(0) @binding(1) var<storage, read_write> output: array<f64>;
@group(0) @binding(2) var<uniform> params: Params;

@compute @workgroup_size(16, 16)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    let x = global_id.x;
    let y = global_id.y;
    
    if (x >= params.width || y >= params.height) {
        return;
    }
    
    let px = f64(x) - f64(params.cx);
    let py = f64(y) - f64(params.cy);
    
    // Inverse transform
    let det = f64(params.a) * f64(params.e) - f64(params.b) * f64(params.d);
    if (abs(det) > 1e-8) {
        let src_x = (f64(params.e) * (px - f64(params.c)) - f64(params.b) * (py - f64(params.f))) / det + f64(params.cx);
        let src_y = (-f64(params.d) * (px - f64(params.c)) + f64(params.a) * (py - f64(params.f))) / det + f64(params.cy);
        
        // Bilinear interpolation
        if (src_x >= 0.0 && src_x < f64(params.width) - 1.0 &&
            src_y >= 0.0 && src_y < f64(params.height) - 1.0) {
            let x0 = u32(src_x);
            let y0 = u32(src_y);
            let dx = src_x - f64(x0);
            let dy = src_y - f64(y0);
            
            for (var c = 0u; c < params.channels; c = c + 1u) {
                let idx_base = c * params.height * params.width;
                let v00 = input[idx_base + y0 * params.width + x0];
                let v01 = input[idx_base + y0 * params.width + x0 + 1u];
                let v10 = input[idx_base + (y0 + 1u) * params.width + x0];
                let v11 = input[idx_base + (y0 + 1u) * params.width + x0 + 1u];
                
                let val = v00 * (1.0 - dx) * (1.0 - dy) +
                         v01 * dx * (1.0 - dy) +
                         v10 * (1.0 - dx) * dy +
                         v11 * dx * dy;
                
                output[idx_base + y * params.width + x] = val;
            }
        }
    }
}