code-atlas 0.1.0

Render local code repositories as architectural treemaps with line-addressed, hierarchically bundled call graphs
Documentation
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(1)
var<storage, read> calls: array<CallRecord>;
@group(0) @binding(2)
var<storage, read> instances: array<TileInstance>;
@group(0) @binding(3)
var<storage, read> sampled_points: array<SampledPoint>;
@group(0) @binding(4)
var<uniform> params: Params;

struct VertexOutput {
    @builtin(position) position: vec4<f32>,
    @location(0) density: vec4<f32>,
};

fn safe_normal(start: vec2<f32>, end: vec2<f32>) -> vec2<f32> {
    let delta = end - start;
    let magnitude = max(length(delta), 0.000001);
    return vec2<f32>(-delta.y, delta.x) / magnitude;
}

fn joined_offset(
    previous: vec2<f32>,
    current: vec2<f32>,
    next: vec2<f32>,
    half_width: f32,
) -> vec2<f32> {
    let incoming = safe_normal(previous, current);
    let outgoing = safe_normal(current, next);
    let sum = incoming + outgoing;
    let sum_length = length(sum);
    if sum_length <= 0.000001 {
        return outgoing * half_width;
    }
    let miter = sum / sum_length;
    let denominator = max(abs(dot(miter, outgoing)), 0.25);
    let miter_length = min(half_width / denominator, half_width * 2.5);
    return miter * miter_length;
}

fn point_for(instance_index: u32, sample: u32) -> vec2<f32> {
    return sampled_points[instance_index * params.counts.x + sample].position;
}

@vertex
fn vs_main(
    @builtin(vertex_index) vertex_index: u32,
    @builtin(instance_index) instance_index: u32,
) -> VertexOutput {
    let instance = instances[instance_index];
    let call = calls[instance.call_index];
    let segment = vertex_index / 6u;
    var output: VertexOutput;
    if segment >= call.segment_count {
        output.position = vec4<f32>(2.0, 2.0, 0.0, 1.0);
        output.density = vec4<f32>(0.0);
        return output;
    }

    let start = point_for(instance_index, segment);
    let end = point_for(instance_index, segment + 1u);
    let pass_settings = select(params.pass0, params.pass1, instance.pass_index == 1u);
    var start_offset = safe_normal(start, end) * pass_settings.x;
    if segment > 0u {
        start_offset = joined_offset(
            point_for(instance_index, segment - 1u),
            start,
            end,
            pass_settings.x,
        );
    }
    var end_offset = safe_normal(start, end) * pass_settings.x;
    if segment + 1u < call.segment_count {
        end_offset = joined_offset(
            start,
            end,
            point_for(instance_index, segment + 2u),
            pass_settings.x,
        );
    }

    let corner = vertex_index % 6u;
    var point = start + start_offset;
    var amount = f32(segment) / f32(call.segment_count);
    if corner == 1u || corner == 4u {
        point = start - start_offset;
    } else if corner == 2u || corner == 3u {
        point = end + end_offset;
        amount = f32(segment + 1u) / f32(call.segment_count);
    } else if corner == 5u {
        point = end - end_offset;
        amount = f32(segment + 1u) / f32(call.segment_count);
    }

    let linear_color = mix(params.source.rgb, params.destination.rgb, amount);
    output.position = vec4<f32>(
        point.x / params.viewport.z * 2.0 - 1.0,
        1.0 - point.y / params.viewport.w * 2.0,
        0.0,
        1.0,
    );
    output.density = vec4<f32>(linear_color * pass_settings.y, pass_settings.y);
    return output;
}

@fragment
fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
    return input.density;
}