code-atlas 0.2.0

Render local code repositories as architectural treemaps with line-addressed, hierarchically bundled call graphs
Documentation
struct ControlPoint {
    position: vec2<f32>,
};

struct CallRecord {
    control_offset: u32,
    control_count: u32,
    segment_count: u32,
    seed: u32,
};

struct TileInstance {
    call_index: u32,
    pass_index: u32,
};

struct SampledPoint {
    position: vec2<f32>,
};

struct Params {
    viewport: vec4<f32>,
    source: vec4<f32>,
    destination: vec4<f32>,
    pass0: vec4<f32>,
    pass1: vec4<f32>,
    settings: vec4<f32>,
    counts: vec4<u32>,
};

@group(0) @binding(0)
var<storage, read> controls: array<ControlPoint>;
@group(0) @binding(1)
var<storage, read> calls: array<CallRecord>;
@group(0) @binding(2)
var<storage, read> instances: array<TileInstance>;
@group(0) @binding(3)
var<storage, read_write> sampled_points: array<SampledPoint>;
@group(0) @binding(4)
var<uniform> params: Params;

fn knot(index: u32, control_count: u32, degree: u32) -> f32 {
    if index <= degree {
        return 0.0;
    }
    if index >= control_count {
        return 1.0;
    }
    return f32(index - degree) / f32(control_count - degree);
}

fn bundled_control(call: CallRecord, index: u32) -> vec2<f32> {
    let point = controls[call.control_offset + index].position;
    let first = controls[call.control_offset].position;
    let last = controls[call.control_offset + call.control_count - 1u].position;
    let amount = f32(index) / f32(max(call.control_count - 1u, 1u));
    let direct = mix(first, last, amount);
    return mix(direct, point, params.settings.x);
}

fn spline_point(call: CallRecord, amount: f32) -> vec2<f32> {
    let degree = min(call.control_count - 1u, 3u);
    var span = call.control_count - 1u;
    if amount < 1.0 {
        span = min(
            degree + u32(floor(amount * f32(call.control_count - degree))),
            call.control_count - 1u,
        );
    }

    var points: array<vec2<f32>, 4>;
    for (var index = 0u; index <= degree; index += 1u) {
        points[index] = bundled_control(call, span - degree + index);
    }
    for (var level = 1u; level <= degree; level += 1u) {
        var index = degree;
        loop {
            if index < level {
                break;
            }
            let knot_index = span - degree + index;
            let denominator =
                knot(knot_index + degree + 1u - level, call.control_count, degree)
                - knot(knot_index, call.control_count, degree);
            var alpha = 0.0;
            if abs(denominator) > 0.000001 {
                alpha = (amount - knot(knot_index, call.control_count, degree)) / denominator;
            }
            points[index] = mix(points[index - 1u], points[index], alpha);
            if index == 0u {
                break;
            }
            index -= 1u;
        }
    }
    return points[degree];
}

fn hash(value: u32) -> u32 {
    var result = value;
    result ^= result >> 16u;
    result *= 0x7feb352du;
    result ^= result >> 15u;
    result *= 0x846ca68bu;
    result ^= result >> 16u;
    return result;
}

fn jitter(seed: u32, sample: u32, pass_index: u32, amplitude: f32) -> vec2<f32> {
    let base = seed ^ (sample * 0x9e3779b9u) ^ (pass_index * 0x85ebca6bu);
    let x = f32(hash(base) & 0x00ffffffu) / 16777215.0;
    let y = f32(hash(base ^ 0xc2b2ae35u) & 0x00ffffffu) / 16777215.0;
    return (vec2<f32>(x, y) * 2.0 - 1.0) * amplitude;
}

@compute @workgroup_size(8, 8, 1)
fn compute_points(@builtin(global_invocation_id) id: vec3<u32>) {
    let sample = id.x;
    let instance_index = id.y;
    if instance_index >= params.counts.y || sample >= params.counts.x {
        return;
    }
    let instance = instances[instance_index];
    let call = calls[instance.call_index];
    if sample > call.segment_count {
        return;
    }
    let amount = f32(sample) / f32(max(call.segment_count, 1u));
    let pass_settings = select(params.pass0, params.pass1, instance.pass_index == 1u);
    let point = spline_point(call, amount)
        + jitter(call.seed, sample, instance.pass_index, pass_settings.z)
        - params.viewport.xy;
    sampled_points[instance_index * params.counts.x + sample].position = point;
}