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(¶ms),
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 ¶ms_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 ¶ms_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)) = ×tamp_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}