Skip to main content

code_atlas/
render_wgpu.rs

1use std::{fs, path::Path, sync::mpsc, time::Instant};
2
3use anyhow::{Context, Result, anyhow, ensure};
4use bytemuck::{Pod, Zeroable};
5use tiny_skia::{IntSize, Pixmap};
6use wgpu::util::DeviceExt;
7
8use crate::{
9    layout::{LayoutOptions, call_control_points},
10    model::Atlas,
11    render::{
12        CallTile, CallTileViewport, Palette, RenderOptions, RenderStats, draw_labels,
13        effective_call_opacity, optical_density_description, plan_call_tiles,
14        render_software_base_png,
15    },
16};
17
18const DENSITY_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
19const OUTPUT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
20const SAMPLE_COUNT: u32 = 4;
21const SPLINE_COMPUTE_SHADER: &str = include_str!("spline_density.wgsl");
22const SPLINE_RENDER_SHADER: &str = include_str!("spline_render.wgsl");
23
24const RESOLVE_SHADER: &str = r#"
25@group(0) @binding(0)
26var density_texture: texture_2d<f32>;
27
28struct VertexOutput {
29    @builtin(position) position: vec4<f32>,
30};
31
32@vertex
33fn vs_main(@builtin(vertex_index) index: u32) -> VertexOutput {
34    var positions = array<vec2<f32>, 3>(
35        vec2<f32>(-1.0, -1.0),
36        vec2<f32>(3.0, -1.0),
37        vec2<f32>(-1.0, 3.0),
38    );
39    var output: VertexOutput;
40    output.position = vec4<f32>(positions[index], 0.0, 1.0);
41    return output;
42}
43
44fn linear_to_srgb(value: f32) -> f32 {
45    if value <= 0.0031308 {
46        return value * 12.92;
47    }
48    return 1.055 * pow(value, 1.0 / 2.4) - 0.055;
49}
50
51@fragment
52fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
53    let pixel = vec2<i32>(input.position.xy);
54    let deposited = textureLoad(density_texture, pixel, 0);
55    if deposited.a <= 0.000001 {
56        return vec4<f32>(0.0);
57    }
58    let alpha = 1.0 - exp(-deposited.a);
59    let linear = clamp(deposited.rgb / deposited.a, vec3<f32>(0.0), vec3<f32>(1.0));
60    let srgb = vec3<f32>(
61        linear_to_srgb(linear.r),
62        linear_to_srgb(linear.g),
63        linear_to_srgb(linear.b),
64    );
65    return vec4<f32>(srgb * alpha, alpha);
66}
67"#;
68
69#[repr(C)]
70#[derive(Clone, Copy, Pod, Zeroable)]
71struct GpuControlPoint {
72    position: [f32; 2],
73}
74
75#[repr(C)]
76#[derive(Clone, Copy, Pod, Zeroable)]
77struct GpuCallRecord {
78    control_offset: u32,
79    control_count: u32,
80    segment_count: u32,
81    seed: u32,
82}
83
84#[repr(C)]
85#[derive(Clone, Copy, Pod, Zeroable)]
86struct GpuTileInstance {
87    call_index: u32,
88    pass_index: u32,
89}
90
91#[repr(C)]
92#[derive(Clone, Copy, Pod, Zeroable)]
93struct GpuSplineParams {
94    viewport: [f32; 4],
95    source: [f32; 4],
96    target: [f32; 4],
97    pass0: [f32; 4],
98    pass1: [f32; 4],
99    settings: [f32; 4],
100    counts: [u32; 4],
101}
102
103pub(crate) struct GpuSplineScene {
104    controls: wgpu::Buffer,
105    calls: wgpu::Buffer,
106    call_ids: Vec<u64>,
107    segment_counts: Vec<u32>,
108    max_segments: u32,
109}
110
111#[derive(Debug, Clone, Copy, Default)]
112pub(crate) struct GpuPassTimings {
113    pub spline_evaluation_ms: Option<f64>,
114    pub rasterization_ms: Option<f64>,
115}
116
117pub(crate) struct WgpuDensityRenderer {
118    device: wgpu::Device,
119    queue: wgpu::Queue,
120    adapter_name: String,
121    spline_compute_pipeline: wgpu::ComputePipeline,
122    accumulate_pipeline: wgpu::RenderPipeline,
123    compute_bind_group_layout: wgpu::BindGroupLayout,
124    accumulate_bind_group_layout: wgpu::BindGroupLayout,
125    resolve_pipeline: wgpu::RenderPipeline,
126    resolve_bind_group_layout: wgpu::BindGroupLayout,
127    timestamp_queries: bool,
128}
129
130fn create_spline_bind_group_layout(
131    device: &wgpu::Device,
132    sampled_points_read_only: bool,
133    visibility: wgpu::ShaderStages,
134) -> wgpu::BindGroupLayout {
135    let storage = |binding, read_only| wgpu::BindGroupLayoutEntry {
136        binding,
137        visibility,
138        ty: wgpu::BindingType::Buffer {
139            ty: wgpu::BufferBindingType::Storage { read_only },
140            has_dynamic_offset: false,
141            min_binding_size: None,
142        },
143        count: None,
144    };
145    device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
146        label: Some(if sampled_points_read_only {
147            "code-atlas GPU spline render bind group layout"
148        } else {
149            "code-atlas GPU spline compute bind group layout"
150        }),
151        entries: &[
152            storage(0, true),
153            storage(1, true),
154            storage(2, true),
155            storage(3, sampled_points_read_only),
156            wgpu::BindGroupLayoutEntry {
157                binding: 4,
158                visibility,
159                ty: wgpu::BindingType::Buffer {
160                    ty: wgpu::BufferBindingType::Uniform,
161                    has_dynamic_offset: false,
162                    min_binding_size: None,
163                },
164                count: None,
165            },
166        ],
167    })
168}
169
170impl WgpuDensityRenderer {
171    pub(crate) fn new() -> Result<Self> {
172        let instance = wgpu::Instance::default();
173        let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
174            power_preference: wgpu::PowerPreference::HighPerformance,
175            compatible_surface: None,
176            force_fallback_adapter: false,
177            apply_limit_buckets: false,
178        }))
179        .context("no compatible GPU adapter is available for the wgpu backend")?;
180        let density_features = adapter.get_texture_format_features(DENSITY_FORMAT);
181        ensure!(
182            density_features
183                .flags
184                .contains(wgpu::TextureFormatFeatureFlags::BLENDABLE),
185            "the GPU adapter does not support blendable RGBA16Float density textures"
186        );
187        ensure!(
188            density_features
189                .flags
190                .contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_X4)
191                && density_features
192                    .flags
193                    .contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_RESOLVE),
194            "the GPU adapter does not support 4x multisampled RGBA16Float density textures"
195        );
196        let adapter_info = adapter.get_info();
197        let timestamp_queries = adapter.features().contains(wgpu::Features::TIMESTAMP_QUERY);
198        let required_features = if timestamp_queries {
199            wgpu::Features::TIMESTAMP_QUERY
200        } else {
201            wgpu::Features::empty()
202        };
203        let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
204            label: Some("code-atlas optical-density device"),
205            required_features,
206            ..Default::default()
207        }))
208        .context("cannot create the wgpu optical-density device")?;
209
210        let spline_compute_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
211            label: Some("code-atlas GPU spline compute shader"),
212            source: wgpu::ShaderSource::Wgsl(SPLINE_COMPUTE_SHADER.into()),
213        });
214        let spline_render_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
215            label: Some("code-atlas GPU spline render shader"),
216            source: wgpu::ShaderSource::Wgsl(SPLINE_RENDER_SHADER.into()),
217        });
218        let compute_bind_group_layout =
219            create_spline_bind_group_layout(&device, false, wgpu::ShaderStages::COMPUTE);
220        let accumulate_bind_group_layout =
221            create_spline_bind_group_layout(&device, true, wgpu::ShaderStages::VERTEX);
222        let compute_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
223            label: Some("code-atlas GPU spline compute layout"),
224            bind_group_layouts: &[Some(&compute_bind_group_layout)],
225            immediate_size: 0,
226        });
227        let spline_compute_pipeline =
228            device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
229                label: Some("code-atlas GPU spline evaluation pipeline"),
230                layout: Some(&compute_layout),
231                module: &spline_compute_shader,
232                entry_point: Some("compute_points"),
233                compilation_options: Default::default(),
234                cache: None,
235            });
236        let accumulate_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
237            label: Some("code-atlas optical-density accumulation layout"),
238            bind_group_layouts: &[Some(&accumulate_bind_group_layout)],
239            immediate_size: 0,
240        });
241        let accumulate_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
242            label: Some("code-atlas optical-density accumulation pipeline"),
243            layout: Some(&accumulate_layout),
244            vertex: wgpu::VertexState {
245                module: &spline_render_shader,
246                entry_point: Some("vs_main"),
247                compilation_options: Default::default(),
248                buffers: &[],
249            },
250            primitive: wgpu::PrimitiveState {
251                topology: wgpu::PrimitiveTopology::TriangleList,
252                ..Default::default()
253            },
254            depth_stencil: None,
255            multisample: wgpu::MultisampleState {
256                count: SAMPLE_COUNT,
257                ..Default::default()
258            },
259            fragment: Some(wgpu::FragmentState {
260                module: &spline_render_shader,
261                entry_point: Some("fs_main"),
262                compilation_options: Default::default(),
263                targets: &[Some(wgpu::ColorTargetState {
264                    format: DENSITY_FORMAT,
265                    blend: Some(wgpu::BlendState::ADDITIVE),
266                    write_mask: wgpu::ColorWrites::ALL,
267                })],
268            }),
269            multiview_mask: None,
270            cache: None,
271        });
272
273        let resolve_bind_group_layout =
274            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
275                label: Some("code-atlas optical-density resolve bind group layout"),
276                entries: &[wgpu::BindGroupLayoutEntry {
277                    binding: 0,
278                    visibility: wgpu::ShaderStages::FRAGMENT,
279                    ty: wgpu::BindingType::Texture {
280                        sample_type: wgpu::TextureSampleType::Float { filterable: false },
281                        view_dimension: wgpu::TextureViewDimension::D2,
282                        multisampled: false,
283                    },
284                    count: None,
285                }],
286            });
287        let resolve_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
288            label: Some("code-atlas optical-density resolve shader"),
289            source: wgpu::ShaderSource::Wgsl(RESOLVE_SHADER.into()),
290        });
291        let resolve_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
292            label: Some("code-atlas optical-density resolve layout"),
293            bind_group_layouts: &[Some(&resolve_bind_group_layout)],
294            immediate_size: 0,
295        });
296        let resolve_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
297            label: Some("code-atlas optical-density resolve pipeline"),
298            layout: Some(&resolve_layout),
299            vertex: wgpu::VertexState {
300                module: &resolve_shader,
301                entry_point: Some("vs_main"),
302                compilation_options: Default::default(),
303                buffers: &[],
304            },
305            primitive: wgpu::PrimitiveState::default(),
306            depth_stencil: None,
307            multisample: wgpu::MultisampleState::default(),
308            fragment: Some(wgpu::FragmentState {
309                module: &resolve_shader,
310                entry_point: Some("fs_main"),
311                compilation_options: Default::default(),
312                targets: &[Some(wgpu::ColorTargetState {
313                    format: OUTPUT_FORMAT,
314                    blend: None,
315                    write_mask: wgpu::ColorWrites::ALL,
316                })],
317            }),
318            multiview_mask: None,
319            cache: None,
320        });
321
322        Ok(Self {
323            device,
324            queue,
325            adapter_name: format!("{} ({:?})", adapter_info.name, adapter_info.backend),
326            spline_compute_pipeline,
327            accumulate_pipeline,
328            compute_bind_group_layout,
329            accumulate_bind_group_layout,
330            resolve_pipeline,
331            resolve_bind_group_layout,
332            timestamp_queries,
333        })
334    }
335
336    pub(crate) fn adapter_name(&self) -> &str {
337        &self.adapter_name
338    }
339
340    pub(crate) fn max_texture_dimension(&self) -> u32 {
341        self.device.limits().max_texture_dimension_2d
342    }
343
344    pub(crate) fn prepare_scene(&self, atlas: &Atlas) -> Result<GpuSplineScene> {
345        let mut controls = Vec::new();
346        let mut records = Vec::with_capacity(atlas.calls.len());
347        let mut call_ids = Vec::with_capacity(atlas.calls.len());
348        let mut segment_counts = Vec::with_capacity(atlas.calls.len());
349        let mut max_segments = 64_u32;
350        for call in &atlas.calls {
351            let control_points = call_control_points(atlas, call);
352            ensure!(
353                control_points.len() >= 2,
354                "call {} has fewer than two hierarchy control points",
355                call.id
356            );
357            let control_offset = u32::try_from(controls.len())
358                .context("GPU spline control-point offset exceeds u32")?;
359            let control_count = u32::try_from(control_points.len())
360                .context("GPU spline control-point count exceeds u32")?;
361            controls.extend(control_points.into_iter().map(|point| GpuControlPoint {
362                position: [point.x as f32, point.y as f32],
363            }));
364            let degree = control_count.saturating_sub(1).min(3);
365            let segment_count = control_count
366                .saturating_sub(degree)
367                .saturating_mul(16)
368                .max(64);
369            max_segments = max_segments.max(segment_count);
370            let seed = (call.id as u32) ^ ((call.id >> 32) as u32).rotate_left(13) ^ 0xca11_517e;
371            records.push(GpuCallRecord {
372                control_offset,
373                control_count,
374                segment_count,
375                seed,
376            });
377            call_ids.push(call.id);
378            segment_counts.push(segment_count);
379        }
380        if controls.is_empty() {
381            controls.push(GpuControlPoint {
382                position: [0.0, 0.0],
383            });
384        }
385        if records.is_empty() {
386            records.push(GpuCallRecord {
387                control_offset: 0,
388                control_count: 1,
389                segment_count: 0,
390                seed: 0,
391            });
392        }
393        let limits = self.device.limits();
394        let control_bytes = std::mem::size_of_val(controls.as_slice()) as u64;
395        let call_bytes = std::mem::size_of_val(records.as_slice()) as u64;
396        ensure!(
397            control_bytes <= limits.max_storage_buffer_binding_size
398                && call_bytes <= limits.max_storage_buffer_binding_size,
399            "GPU spline scene exceeds the adapter's storage-buffer binding limit"
400        );
401        let controls = self
402            .device
403            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
404                label: Some("code-atlas persistent hierarchy control points"),
405                contents: bytemuck::cast_slice(&controls),
406                usage: wgpu::BufferUsages::STORAGE,
407            });
408        let calls = self
409            .device
410            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
411                label: Some("code-atlas persistent compact call records"),
412                contents: bytemuck::cast_slice(&records),
413                usage: wgpu::BufferUsages::STORAGE,
414            });
415        Ok(GpuSplineScene {
416            controls,
417            calls,
418            call_ids,
419            segment_counts,
420            max_segments,
421        })
422    }
423
424    pub(crate) fn render_call_tile(
425        &self,
426        scene: &GpuSplineScene,
427        layout: &LayoutOptions,
428        render: &RenderOptions,
429        call_indices: &[usize],
430        viewport: CallTileViewport,
431    ) -> Result<(Pixmap, usize)> {
432        let (pixmap, calls, _) =
433            self.render_call_tile_profiled(scene, layout, render, call_indices, viewport)?;
434        Ok((pixmap, calls))
435    }
436
437    pub(crate) fn render_call_tile_profiled(
438        &self,
439        scene: &GpuSplineScene,
440        layout: &LayoutOptions,
441        render: &RenderOptions,
442        call_indices: &[usize],
443        viewport: CallTileViewport,
444    ) -> Result<(Pixmap, usize, GpuPassTimings)> {
445        ensure!(
446            viewport.width > 0 && viewport.height > 0,
447            "GPU call tile dimensions must be non-zero"
448        );
449        let max_dimension = self.device.limits().max_texture_dimension_2d;
450        ensure!(
451            viewport.width <= max_dimension && viewport.height <= max_dimension,
452            "GPU call tile {}x{} exceeds the adapter's {}-pixel texture limit",
453            viewport.width,
454            viewport.height,
455            max_dimension
456        );
457        let extent = wgpu::Extent3d {
458            width: viewport.width,
459            height: viewport.height,
460            depth_or_array_layers: 1,
461        };
462        let density_msaa = self.device.create_texture(&wgpu::TextureDescriptor {
463            label: Some("code-atlas multisampled optical-density tile"),
464            size: extent,
465            mip_level_count: 1,
466            sample_count: SAMPLE_COUNT,
467            dimension: wgpu::TextureDimension::D2,
468            format: DENSITY_FORMAT,
469            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
470            view_formats: &[],
471        });
472        let density_resolved = self.device.create_texture(&wgpu::TextureDescriptor {
473            label: Some("code-atlas resolved optical-density tile"),
474            size: extent,
475            mip_level_count: 1,
476            sample_count: 1,
477            dimension: wgpu::TextureDimension::D2,
478            format: DENSITY_FORMAT,
479            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
480            view_formats: &[],
481        });
482        let output = self.device.create_texture(&wgpu::TextureDescriptor {
483            label: Some("code-atlas resolved call tile"),
484            size: extent,
485            mip_level_count: 1,
486            sample_count: 1,
487            dimension: wgpu::TextureDimension::D2,
488            format: OUTPUT_FORMAT,
489            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
490            view_formats: &[],
491        });
492        let density_msaa_view = density_msaa.create_view(&wgpu::TextureViewDescriptor::default());
493        let density_resolved_view =
494            density_resolved.create_view(&wgpu::TextureViewDescriptor::default());
495        let output_view = output.create_view(&wgpu::TextureViewDescriptor::default());
496
497        let opacity = effective_call_opacity(scene.call_ids.len(), render);
498        let mut ordered_indices = call_indices.to_vec();
499        ordered_indices.sort_unstable_by_key(|index| {
500            (
501                scene.call_ids.get(*index).copied().unwrap_or(u64::MAX),
502                *index,
503            )
504        });
505        let mut instances = Vec::with_capacity(ordered_indices.len().saturating_mul(2));
506        let mut calls_drawn = 0;
507        for index in ordered_indices {
508            let Some(&segment_count) = scene.segment_counts.get(index) else {
509                continue;
510            };
511            if segment_count == 0 {
512                continue;
513            }
514            let call_index = u32::try_from(index).context("GPU call index exceeds u32")?;
515            instances.push(GpuTileInstance {
516                call_index,
517                pass_index: 0,
518            });
519            instances.push(GpuTileInstance {
520                call_index,
521                pass_index: 1,
522            });
523            calls_drawn += 1;
524        }
525        self.clear_density_target(&density_msaa_view, &density_resolved_view);
526        let batch_capacity = self.instance_batch_capacity(scene)?;
527        let mut pass_timings = GpuPassTimings::default();
528        for batch in instances.chunks(batch_capacity) {
529            let batch_timings = self.submit_spline_instances(
530                scene,
531                layout,
532                render,
533                opacity,
534                viewport,
535                batch,
536                &density_msaa_view,
537                &density_resolved_view,
538            )?;
539            pass_timings.spline_evaluation_ms = sum_optional(
540                pass_timings.spline_evaluation_ms,
541                batch_timings.spline_evaluation_ms,
542            );
543            pass_timings.rasterization_ms = sum_optional(
544                pass_timings.rasterization_ms,
545                batch_timings.rasterization_ms,
546            );
547        }
548
549        let resolve_bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
550            label: Some("code-atlas optical-density resolve bind group"),
551            layout: &self.resolve_bind_group_layout,
552            entries: &[wgpu::BindGroupEntry {
553                binding: 0,
554                resource: wgpu::BindingResource::TextureView(&density_resolved_view),
555            }],
556        });
557        let mut encoder = self
558            .device
559            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
560                label: Some("code-atlas optical-density resolve encoder"),
561            });
562        {
563            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
564                label: Some("code-atlas optical-density resolve pass"),
565                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
566                    view: &output_view,
567                    depth_slice: None,
568                    resolve_target: None,
569                    ops: wgpu::Operations {
570                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
571                        store: wgpu::StoreOp::Store,
572                    },
573                })],
574                depth_stencil_attachment: None,
575                timestamp_writes: None,
576                occlusion_query_set: None,
577                multiview_mask: None,
578            });
579            pass.set_pipeline(&self.resolve_pipeline);
580            pass.set_bind_group(0, &resolve_bind_group, &[]);
581            pass.draw(0..3, 0..1);
582        }
583        self.queue.submit(Some(encoder.finish()));
584
585        let pixels = read_texture(&self.device, &self.queue, &output, extent)?;
586        let size = IntSize::from_wh(viewport.width, viewport.height)
587            .context("invalid GPU call tile dimensions")?;
588        let pixmap = Pixmap::from_vec(pixels, size).context("invalid GPU call tile pixels")?;
589        Ok((pixmap, calls_drawn, pass_timings))
590    }
591
592    fn instance_batch_capacity(&self, scene: &GpuSplineScene) -> Result<usize> {
593        let point_stride = u64::from(scene.max_segments + 1);
594        let bytes_per_instance = point_stride
595            .checked_mul(std::mem::size_of::<GpuControlPoint>() as u64)
596            .context("GPU sampled-point stride overflows")?;
597        let limits = self.device.limits();
598        let storage_capacity = limits
599            .max_storage_buffer_binding_size
600            .min(limits.max_buffer_size)
601            / bytes_per_instance.max(1);
602        let dispatch_capacity = u64::from(limits.max_compute_workgroups_per_dimension) * 8;
603        let capacity = storage_capacity
604            .min(dispatch_capacity)
605            .min(usize::MAX as u64) as usize;
606        let capacity = capacity & !1;
607        ensure!(
608            capacity >= 2,
609            "GPU storage limits cannot hold one two-pass spline instance"
610        );
611        Ok(capacity)
612    }
613
614    fn clear_density_target(
615        &self,
616        multisampled_view: &wgpu::TextureView,
617        resolved_view: &wgpu::TextureView,
618    ) {
619        let mut encoder = self
620            .device
621            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
622                label: Some("code-atlas optical-density clear encoder"),
623            });
624        {
625            let _pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
626                label: Some("code-atlas optical-density clear pass"),
627                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
628                    view: multisampled_view,
629                    depth_slice: None,
630                    resolve_target: Some(resolved_view),
631                    ops: wgpu::Operations {
632                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
633                        store: wgpu::StoreOp::Store,
634                    },
635                })],
636                depth_stencil_attachment: None,
637                timestamp_writes: None,
638                occlusion_query_set: None,
639                multiview_mask: None,
640            });
641        }
642        self.queue.submit(Some(encoder.finish()));
643    }
644
645    #[allow(clippy::too_many_arguments)]
646    fn submit_spline_instances(
647        &self,
648        scene: &GpuSplineScene,
649        layout: &LayoutOptions,
650        render: &RenderOptions,
651        opacity: u8,
652        viewport: CallTileViewport,
653        instances: &[GpuTileInstance],
654        multisampled_view: &wgpu::TextureView,
655        resolved_view: &wgpu::TextureView,
656    ) -> Result<GpuPassTimings> {
657        if instances.is_empty() {
658            return Ok(GpuPassTimings::default());
659        }
660        let point_stride = scene.max_segments + 1;
661        let point_count = u64::try_from(instances.len())
662            .context("GPU tile instance count exceeds u64")?
663            .checked_mul(u64::from(point_stride))
664            .context("GPU sampled-point count overflows")?;
665        let point_bytes = point_count
666            .checked_mul(std::mem::size_of::<GpuControlPoint>() as u64)
667            .context("GPU sampled-point buffer size overflows")?;
668        let instance_buffer = self
669            .device
670            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
671                label: Some("code-atlas tile-local call/pass IDs"),
672                contents: bytemuck::cast_slice(instances),
673                usage: wgpu::BufferUsages::STORAGE,
674            });
675        let sampled_points = self.device.create_buffer(&wgpu::BufferDescriptor {
676            label: Some("code-atlas GPU-evaluated spline points"),
677            size: point_bytes,
678            usage: wgpu::BufferUsages::STORAGE,
679            mapped_at_creation: false,
680        });
681        let palette = Palette::for_theme(render.theme);
682        let drawing_scale = (layout.width.min(layout.height) as f32 / 1080.0).max(0.5);
683        let pass = |alpha_scale: f32, width_scale: f32, amplitude: f32| {
684            let alpha = (f32::from(opacity) * alpha_scale).round().max(1.0) / 255.0;
685            [
686                render.call_width * drawing_scale * width_scale * 0.5,
687                -(1.0 - alpha.min(0.999_999)).ln(),
688                amplitude,
689                0.0,
690            ]
691        };
692        let params = GpuSplineParams {
693            viewport: [
694                viewport.x as f32,
695                viewport.y as f32,
696                viewport.width as f32,
697                viewport.height as f32,
698            ],
699            source: linear_rgba(palette.direction_source),
700            target: linear_rgba(palette.direction_target),
701            pass0: pass(0.62, 0.82, 0.14),
702            pass1: pass(0.38, 1.28, 0.34),
703            settings: [layout.bundle_strength.clamp(0.0, 1.0) as f32, 0.0, 0.0, 0.0],
704            counts: [
705                point_stride,
706                u32::try_from(instances.len()).context("GPU tile instance count exceeds u32")?,
707                scene.max_segments,
708                0,
709            ],
710        };
711        let params_buffer = self
712            .device
713            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
714                label: Some("code-atlas GPU spline tile parameters"),
715                contents: bytemuck::bytes_of(&params),
716                usage: wgpu::BufferUsages::UNIFORM,
717            });
718        let compute_bind_group = self.create_spline_bind_group(
719            &self.compute_bind_group_layout,
720            scene,
721            &instance_buffer,
722            &sampled_points,
723            &params_buffer,
724        );
725        let render_bind_group = self.create_spline_bind_group(
726            &self.accumulate_bind_group_layout,
727            scene,
728            &instance_buffer,
729            &sampled_points,
730            &params_buffer,
731        );
732        let timestamp_resources = self.timestamp_queries.then(|| {
733            let query_set = self.device.create_query_set(&wgpu::QuerySetDescriptor {
734                label: Some("code-atlas GPU spline phase timestamps"),
735                ty: wgpu::QueryType::Timestamp,
736                count: 4,
737            });
738            let resolve = self.device.create_buffer(&wgpu::BufferDescriptor {
739                label: Some("code-atlas GPU timestamp resolve"),
740                size: 32,
741                usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC,
742                mapped_at_creation: false,
743            });
744            let readback = self.device.create_buffer(&wgpu::BufferDescriptor {
745                label: Some("code-atlas GPU timestamp readback"),
746                size: 32,
747                usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
748                mapped_at_creation: false,
749            });
750            (query_set, resolve, readback)
751        });
752        let mut encoder = self
753            .device
754            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
755                label: Some("code-atlas GPU spline evaluation and density encoder"),
756            });
757        {
758            let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
759                label: Some("code-atlas GPU spline evaluation pass"),
760                timestamp_writes: timestamp_resources.as_ref().map(|(query_set, _, _)| {
761                    wgpu::ComputePassTimestampWrites {
762                        query_set,
763                        beginning_of_pass_write_index: Some(0),
764                        end_of_pass_write_index: Some(1),
765                    }
766                }),
767            });
768            pass.set_pipeline(&self.spline_compute_pipeline);
769            pass.set_bind_group(0, &compute_bind_group, &[]);
770            pass.dispatch_workgroups(
771                point_stride.div_ceil(8),
772                u32::try_from(instances.len())
773                    .context("GPU tile instance count exceeds u32")?
774                    .div_ceil(8),
775                1,
776            );
777        }
778        {
779            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
780                label: Some("code-atlas GPU spline optical-density pass"),
781                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
782                    view: multisampled_view,
783                    depth_slice: None,
784                    resolve_target: Some(resolved_view),
785                    ops: wgpu::Operations {
786                        load: wgpu::LoadOp::Load,
787                        store: wgpu::StoreOp::Store,
788                    },
789                })],
790                depth_stencil_attachment: None,
791                timestamp_writes: timestamp_resources.as_ref().map(|(query_set, _, _)| {
792                    wgpu::RenderPassTimestampWrites {
793                        query_set,
794                        beginning_of_pass_write_index: Some(2),
795                        end_of_pass_write_index: Some(3),
796                    }
797                }),
798                occlusion_query_set: None,
799                multiview_mask: None,
800            });
801            pass.set_pipeline(&self.accumulate_pipeline);
802            pass.set_bind_group(0, &render_bind_group, &[]);
803            pass.draw(
804                0..scene.max_segments.saturating_mul(6),
805                0..u32::try_from(instances.len()).context("GPU instance count exceeds u32")?,
806            );
807        }
808        if let Some((query_set, resolve, readback)) = &timestamp_resources {
809            encoder.resolve_query_set(query_set, 0..4, resolve, 0);
810            encoder.copy_buffer_to_buffer(resolve, 0, readback, 0, 32);
811        }
812        self.queue.submit(Some(encoder.finish()));
813        if let Some((_, _, readback)) = timestamp_resources {
814            let values = read_u64_buffer(&self.device, &readback)?;
815            let period = f64::from(self.queue.get_timestamp_period()) / 1_000_000.0;
816            return Ok(GpuPassTimings {
817                spline_evaluation_ms: Some(values[1].saturating_sub(values[0]) as f64 * period),
818                rasterization_ms: Some(values[3].saturating_sub(values[2]) as f64 * period),
819            });
820        }
821        Ok(GpuPassTimings::default())
822    }
823
824    fn create_spline_bind_group(
825        &self,
826        layout: &wgpu::BindGroupLayout,
827        scene: &GpuSplineScene,
828        instances: &wgpu::Buffer,
829        sampled_points: &wgpu::Buffer,
830        params: &wgpu::Buffer,
831    ) -> wgpu::BindGroup {
832        self.device.create_bind_group(&wgpu::BindGroupDescriptor {
833            label: Some("code-atlas GPU spline bind group"),
834            layout,
835            entries: &[
836                wgpu::BindGroupEntry {
837                    binding: 0,
838                    resource: scene.controls.as_entire_binding(),
839                },
840                wgpu::BindGroupEntry {
841                    binding: 1,
842                    resource: scene.calls.as_entire_binding(),
843                },
844                wgpu::BindGroupEntry {
845                    binding: 2,
846                    resource: instances.as_entire_binding(),
847                },
848                wgpu::BindGroupEntry {
849                    binding: 3,
850                    resource: sampled_points.as_entire_binding(),
851                },
852                wgpu::BindGroupEntry {
853                    binding: 4,
854                    resource: params.as_entire_binding(),
855                },
856            ],
857        })
858    }
859}
860
861pub(crate) fn render_wgpu_png(
862    atlas: &Atlas,
863    output: &Path,
864    layout: &LayoutOptions,
865    render: &RenderOptions,
866) -> Result<RenderStats> {
867    let started = Instant::now();
868    let mut stats = render_software_base_png(atlas, output, layout, render)?;
869    let mut pixmap = Pixmap::load_png(output)
870        .with_context(|| format!("cannot reload software base {}", output.display()))?;
871    let renderer = WgpuDensityRenderer::new()?;
872    let scene = renderer.prepare_scene(atlas)?;
873    let (tiles, calls_drawn, overlap) = plan_call_tiles(atlas, layout, render)?;
874    for tile in &tiles {
875        let (call_tile, _) = render_tile(&renderer, &scene, layout, render, tile)?;
876        composite_tile_core(&mut pixmap, &call_tile, tile);
877    }
878    let labels = draw_labels(&mut pixmap, atlas, layout, Palette::for_theme(render.theme))?;
879    pixmap
880        .save_png(output)
881        .with_context(|| format!("cannot save {}", output.display()))?;
882    stats.backend = "wgpu spline-evaluated optical-density tiled".to_owned();
883    stats.gpu_adapter = Some(renderer.adapter_name().to_owned());
884    stats.call_layer_tiles = tiles.len();
885    stats.call_layer_tile_size = Some(render.pdf_call_tile_size);
886    stats.call_layer_overlap = Some(overlap);
887    stats.calls_drawn = calls_drawn;
888    stats.file_labels_drawn = labels.files;
889    stats.directory_labels_drawn = labels.directories;
890    stats.output_bytes = fs::metadata(output)?.len();
891    stats.effective_call_opacity = effective_call_opacity(atlas.calls.len(), render);
892    stats.call_compositing = optical_density_description();
893    stats.render_ms = started.elapsed().as_millis().min(u128::from(u64::MAX)) as u64;
894    Ok(stats)
895}
896
897pub(crate) fn render_wgpu_call_layer_png(
898    atlas: &Atlas,
899    output: &Path,
900    layout: &LayoutOptions,
901    render: &RenderOptions,
902) -> Result<RenderStats> {
903    let started = Instant::now();
904    let renderer = WgpuDensityRenderer::new()?;
905    let scene = renderer.prepare_scene(atlas)?;
906    let (tiles, calls_drawn, overlap) = plan_call_tiles(atlas, layout, render)?;
907    let mut pixmap = Pixmap::new(layout.width, layout.height)
908        .context("output dimensions are too large for the GPU call renderer")?;
909    for tile in &tiles {
910        let (call_tile, _) = render_tile(&renderer, &scene, layout, render, tile)?;
911        composite_tile_core(&mut pixmap, &call_tile, tile);
912    }
913    if let Some(parent) = output.parent() {
914        fs::create_dir_all(parent)
915            .with_context(|| format!("cannot create output directory {}", parent.display()))?;
916    }
917    pixmap
918        .save_png(output)
919        .with_context(|| format!("cannot save {}", output.display()))?;
920    let palette = Palette::for_theme(render.theme);
921    Ok(RenderStats {
922        backend: "wgpu spline-evaluated optical-density tiled".to_owned(),
923        gpu_adapter: Some(renderer.adapter_name().to_owned()),
924        width: layout.width,
925        height: layout.height,
926        call_layer_width: layout.width,
927        call_layer_height: layout.height,
928        call_layer_dpi: None,
929        call_layer_tiles: tiles.len(),
930        call_layer_tile_size: Some(render.pdf_call_tile_size),
931        call_layer_overlap: Some(overlap),
932        files_drawn: atlas.files().count(),
933        file_labels_drawn: 0,
934        directory_labels_drawn: 0,
935        calls_drawn,
936        directory_boundaries_drawn: atlas
937            .nodes
938            .iter()
939            .filter(|node| node.kind == crate::model::NodeKind::Directory && node.id != 0)
940            .count(),
941        output_bytes: fs::metadata(output)?.len(),
942        effective_call_opacity: effective_call_opacity(atlas.calls.len(), render),
943        call_compositing: optical_density_description(),
944        direction_source_color: palette.direction_source.hex(),
945        direction_target_color: palette.direction_target.hex(),
946        render_ms: started.elapsed().as_millis().min(u128::from(u64::MAX)) as u64,
947        pdf_tile_cache: None,
948    })
949}
950
951fn render_tile(
952    renderer: &WgpuDensityRenderer,
953    scene: &GpuSplineScene,
954    layout: &LayoutOptions,
955    render: &RenderOptions,
956    tile: &CallTile,
957) -> Result<(Pixmap, usize)> {
958    renderer.render_call_tile(
959        scene,
960        layout,
961        render,
962        &tile.call_indices,
963        CallTileViewport {
964            x: tile.render_x,
965            y: tile.render_y,
966            width: tile.render_width,
967            height: tile.render_height,
968        },
969    )
970}
971
972fn linear_rgba(color: crate::render::Rgba) -> [f32; 4] {
973    let convert = |value: u8| {
974        let value = f32::from(value) / 255.0;
975        if value <= 0.04045 {
976            value / 12.92
977        } else {
978            ((value + 0.055) / 1.055).powf(2.4)
979        }
980    };
981    [
982        convert(color.r),
983        convert(color.g),
984        convert(color.b),
985        f32::from(color.a) / 255.0,
986    ]
987}
988
989fn sum_optional(left: Option<f64>, right: Option<f64>) -> Option<f64> {
990    match (left, right) {
991        (Some(left), Some(right)) => Some(left + right),
992        (None, Some(right)) => Some(right),
993        (Some(left), None) => Some(left),
994        (None, None) => None,
995    }
996}
997
998fn composite_tile_core(destination: &mut Pixmap, source: &Pixmap, tile: &CallTile) {
999    for y in tile.core_y..tile.core_y + tile.core_height {
1000        for x in tile.core_x..tile.core_x + tile.core_width {
1001            let source_x = x - tile.render_x;
1002            let source_y = y - tile.render_y;
1003            let source_offset =
1004                (source_y as usize * source.width() as usize + source_x as usize) * 4;
1005            let destination_offset = (y as usize * destination.width() as usize + x as usize) * 4;
1006            let source_pixel = &source.data()[source_offset..source_offset + 4];
1007            let destination_pixel =
1008                &mut destination.data_mut()[destination_offset..destination_offset + 4];
1009            let inverse_alpha = 255_u32 - u32::from(source_pixel[3]);
1010            for channel in 0..3 {
1011                destination_pixel[channel] = (u32::from(source_pixel[channel])
1012                    + (u32::from(destination_pixel[channel]) * inverse_alpha + 127) / 255)
1013                    .min(255) as u8;
1014            }
1015            destination_pixel[3] = (u32::from(source_pixel[3])
1016                + (u32::from(destination_pixel[3]) * inverse_alpha + 127) / 255)
1017                .min(255) as u8;
1018        }
1019    }
1020}
1021
1022fn read_texture(
1023    device: &wgpu::Device,
1024    queue: &wgpu::Queue,
1025    texture: &wgpu::Texture,
1026    extent: wgpu::Extent3d,
1027) -> Result<Vec<u8>> {
1028    let unpadded_bytes_per_row = extent.width * 4;
1029    let alignment = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
1030    let padded_bytes_per_row = unpadded_bytes_per_row.div_ceil(alignment) * alignment;
1031    let output_buffer = device.create_buffer(&wgpu::BufferDescriptor {
1032        label: Some("code-atlas optical-density readback buffer"),
1033        size: u64::from(padded_bytes_per_row) * u64::from(extent.height),
1034        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
1035        mapped_at_creation: false,
1036    });
1037    let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
1038        label: Some("code-atlas optical-density readback encoder"),
1039    });
1040    encoder.copy_texture_to_buffer(
1041        wgpu::TexelCopyTextureInfo {
1042            texture,
1043            mip_level: 0,
1044            origin: wgpu::Origin3d::ZERO,
1045            aspect: wgpu::TextureAspect::All,
1046        },
1047        wgpu::TexelCopyBufferInfo {
1048            buffer: &output_buffer,
1049            layout: wgpu::TexelCopyBufferLayout {
1050                offset: 0,
1051                bytes_per_row: Some(padded_bytes_per_row),
1052                rows_per_image: Some(extent.height),
1053            },
1054        },
1055        extent,
1056    );
1057    queue.submit(Some(encoder.finish()));
1058
1059    let slice = output_buffer.slice(..);
1060    let (sender, receiver) = mpsc::channel();
1061    slice.map_async(wgpu::MapMode::Read, move |result| {
1062        let _ = sender.send(result);
1063    });
1064    device
1065        .poll(wgpu::PollType::wait_indefinitely())
1066        .map_err(|error| anyhow!("GPU optical-density readback poll failed: {error}"))?;
1067    receiver
1068        .recv()
1069        .context("GPU optical-density readback callback was dropped")?
1070        .context("cannot map the GPU optical-density readback buffer")?;
1071
1072    let mapped = slice
1073        .get_mapped_range()
1074        .context("cannot access the GPU optical-density readback buffer")?;
1075    let mut pixels = Vec::with_capacity((unpadded_bytes_per_row * extent.height) as usize);
1076    for row in mapped.chunks_exact(padded_bytes_per_row as usize) {
1077        pixels.extend_from_slice(&row[..unpadded_bytes_per_row as usize]);
1078    }
1079    drop(mapped);
1080    output_buffer.unmap();
1081    Ok(pixels)
1082}
1083
1084fn read_u64_buffer(device: &wgpu::Device, buffer: &wgpu::Buffer) -> Result<[u64; 4]> {
1085    let slice = buffer.slice(..);
1086    let (sender, receiver) = mpsc::channel();
1087    slice.map_async(wgpu::MapMode::Read, move |result| {
1088        let _ = sender.send(result);
1089    });
1090    device
1091        .poll(wgpu::PollType::wait_indefinitely())
1092        .map_err(|error| anyhow!("GPU timestamp readback poll failed: {error}"))?;
1093    receiver
1094        .recv()
1095        .context("GPU timestamp readback callback was dropped")?
1096        .context("cannot map GPU timestamps")?;
1097    let mapped = slice
1098        .get_mapped_range()
1099        .context("cannot access GPU timestamps")?;
1100    let values = bytemuck::try_from_bytes::<[u64; 4]>(&mapped)
1101        .map_err(|error| anyhow!("GPU timestamp buffer has an invalid size: {error:?}"))?
1102        .to_owned();
1103    drop(mapped);
1104    buffer.unmap();
1105    Ok(values)
1106}
1107
1108#[cfg(test)]
1109mod tests {
1110    use std::{collections::HashMap, path::PathBuf};
1111
1112    use crate::{
1113        model::{AnalyzerReport, Atlas, BuildTimings, Callsite, Node, NodeKind, Rect},
1114        render::{Theme, plan_call_tiles, render_software_call_tile},
1115    };
1116
1117    use super::*;
1118
1119    #[test]
1120    fn gpu_density_preserves_order_overlap_reference_and_tile_invariants() {
1121        let Ok(renderer) = WgpuDensityRenderer::new() else {
1122            eprintln!("skipping GPU density invariants because no compatible adapter is available");
1123            return;
1124        };
1125        let (atlas, layout) = fixture();
1126        let scene = renderer.prepare_scene(&atlas).unwrap();
1127        let indices = [0, 1, 2];
1128        let viewport = CallTileViewport {
1129            x: 0,
1130            y: 0,
1131            width: layout.width,
1132            height: layout.height,
1133        };
1134        for theme in [Theme::Architect, Theme::Night] {
1135            let render = RenderOptions {
1136                theme,
1137                pdf_call_tile_size: 64,
1138                ..RenderOptions::default()
1139            };
1140            let (forward, _) = renderer
1141                .render_call_tile(&scene, &layout, &render, &indices, viewport)
1142                .unwrap();
1143            let (reverse, _) = renderer
1144                .render_call_tile(&scene, &layout, &render, &[2, 1, 0], viewport)
1145                .unwrap();
1146            assert_eq!(
1147                forward.data(),
1148                reverse.data(),
1149                "GPU density resolve depends on input order for {theme}"
1150            );
1151
1152            let (single, _) = renderer
1153                .render_call_tile(&scene, &layout, &render, &[0], viewport)
1154                .unwrap();
1155            let (double, _) = renderer
1156                .render_call_tile(&scene, &layout, &render, &[0, 1], viewport)
1157                .unwrap();
1158            assert!(
1159                alpha_sum(&double) > alpha_sum(&single),
1160                "repeated GPU routes do not increase optical density for {theme}"
1161            );
1162
1163            let (cpu, _) =
1164                render_software_call_tile(&atlas, &layout, &render, &indices, viewport).unwrap();
1165            assert_reference_similarity(&cpu, &forward, theme);
1166            assert_gpu_tiles_match(&renderer, &scene, &atlas, &layout, &render, &forward);
1167        }
1168    }
1169
1170    fn assert_reference_similarity(cpu: &Pixmap, gpu: &Pixmap, theme: Theme) {
1171        let mut alpha_difference = 0_u64;
1172        let mut cpu_alpha = 0_u64;
1173        let mut intersection = 0_u64;
1174        let mut union = 0_u64;
1175        for (cpu, gpu) in cpu.data().chunks_exact(4).zip(gpu.data().chunks_exact(4)) {
1176            alpha_difference += u64::from(cpu[3].abs_diff(gpu[3]));
1177            cpu_alpha += u64::from(cpu[3]);
1178            let cpu_covered = cpu[3] >= 4;
1179            let gpu_covered = gpu[3] >= 4;
1180            intersection += u64::from(cpu_covered && gpu_covered);
1181            union += u64::from(cpu_covered || gpu_covered);
1182        }
1183        let relative_alpha_error = alpha_difference as f64 / cpu_alpha.max(1) as f64;
1184        let coverage_iou = intersection as f64 / union.max(1) as f64;
1185        assert!(
1186            relative_alpha_error < 0.45,
1187            "GPU/CPU relative alpha error {relative_alpha_error:.3} is too high for {theme}"
1188        );
1189        assert!(
1190            coverage_iou > 0.72,
1191            "GPU/CPU coverage IoU {coverage_iou:.3} is too low for {theme}"
1192        );
1193    }
1194
1195    fn assert_gpu_tiles_match(
1196        renderer: &WgpuDensityRenderer,
1197        scene: &GpuSplineScene,
1198        atlas: &Atlas,
1199        layout: &LayoutOptions,
1200        render: &RenderOptions,
1201        full: &Pixmap,
1202    ) {
1203        let (tiles, _, _) = plan_call_tiles(atlas, layout, render).unwrap();
1204        assert!(tiles.len() > 1);
1205        for tile in &tiles {
1206            let (pixmap, _) = render_tile(renderer, scene, layout, render, tile).unwrap();
1207            for y in tile.core_y..tile.core_y + tile.core_height {
1208                for x in tile.core_x..tile.core_x + tile.core_width {
1209                    let full_offset = (y as usize * layout.width as usize + x as usize) * 4;
1210                    let local_x = x - tile.render_x;
1211                    let local_y = y - tile.render_y;
1212                    let tile_offset =
1213                        (local_y as usize * tile.render_width as usize + local_x as usize) * 4;
1214                    for channel in 0..4 {
1215                        assert!(
1216                            full.data()[full_offset + channel]
1217                                .abs_diff(pixmap.data()[tile_offset + channel])
1218                                <= 2,
1219                            "GPU tile differs at ({x}, {y}) channel {channel}"
1220                        );
1221                    }
1222                }
1223            }
1224        }
1225    }
1226
1227    fn alpha_sum(pixmap: &Pixmap) -> u64 {
1228        pixmap
1229            .data()
1230            .chunks_exact(4)
1231            .map(|pixel| u64::from(pixel[3]))
1232            .sum()
1233    }
1234
1235    fn fixture() -> (Atlas, LayoutOptions) {
1236        let layout = LayoutOptions {
1237            width: 160,
1238            height: 120,
1239            ..LayoutOptions::default()
1240        };
1241        let file = |id, path: &str, rect| Node {
1242            id,
1243            parent: Some(0),
1244            children: Vec::new(),
1245            kind: NodeKind::File,
1246            name: path.to_owned(),
1247            path: path.to_owned(),
1248            depth: 1,
1249            bytes: 20,
1250            loc: 20,
1251            commits: 1,
1252            weight: 20.0,
1253            language: "rust".to_owned(),
1254            rect,
1255        };
1256        let call = |id, source, source_line, target, target_line, callee: &str| Callsite {
1257            id,
1258            source,
1259            source_line,
1260            target,
1261            target_line: Some(target_line),
1262            callee: callee.to_owned(),
1263            kind: "runtime".to_owned(),
1264            analyzer: "fixture".to_owned(),
1265            confidence: 1.0,
1266        };
1267        let atlas = Atlas {
1268            root_path: PathBuf::from("fixture"),
1269            revision: "test".to_owned(),
1270            dirty: false,
1271            excluded_test_files: 0,
1272            excluded_hidden_files: 0,
1273            excluded_custom_files: 0,
1274            excluded_paths: Vec::new(),
1275            nodes: vec![
1276                Node {
1277                    id: 0,
1278                    parent: None,
1279                    children: vec![1, 2],
1280                    kind: NodeKind::Directory,
1281                    name: "fixture".to_owned(),
1282                    path: String::new(),
1283                    depth: 0,
1284                    bytes: 40,
1285                    loc: 40,
1286                    commits: 2,
1287                    weight: 40.0,
1288                    language: "directory".to_owned(),
1289                    rect: Rect {
1290                        x0: 0.0,
1291                        y0: 0.0,
1292                        x1: 160.0,
1293                        y1: 120.0,
1294                    },
1295                },
1296                file(
1297                    1,
1298                    "a.rs",
1299                    Rect {
1300                        x0: 4.0,
1301                        y0: 4.0,
1302                        x1: 70.0,
1303                        y1: 116.0,
1304                    },
1305                ),
1306                file(
1307                    2,
1308                    "b.rs",
1309                    Rect {
1310                        x0: 90.0,
1311                        y0: 4.0,
1312                        x1: 156.0,
1313                        y1: 116.0,
1314                    },
1315                ),
1316            ],
1317            calls: vec![
1318                call(11, 1, 2, 2, 19, "b::low"),
1319                call(11, 1, 2, 2, 19, "b::low"),
1320                call(7, 2, 3, 1, 18, "a::high"),
1321            ],
1322            path_to_id: HashMap::new(),
1323            report: AnalyzerReport::default(),
1324            timings: BuildTimings::default(),
1325        };
1326        (atlas, layout)
1327    }
1328}