fix(renderer): keep draw-order offsets within clipping planes

src/scene/pipeline/depth_tests.rs

@@ -0,0 +1,370 @@
+//! Pixel regressions for projection and draw-order clipping, using the actual
+//! wire pipelines in both storage and WebGL-compatible packed modes.
+use super::*;
+use crate::scene::view::camera::{Camera, Projection};
+use iced::futures::executor::block_on;
+
+const SIZE: u32 = 512;
+
+fn pixels(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    pipeline: &mut Pipeline,
+    uniforms: &Uniforms,
+    wires: &[WireModel],
+    depths: &rustc_hash::FxHashMap<u64, [f32; 2]>,
+) -> Vec<u8> {
+    let size = wgpu::Extent3d {
+        width: SIZE,
+        height: SIZE,
+        depth_or_array_layers: 1,
+    };
+    let target = device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("draw-order regression"),
+        size,
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+        view_formats: &[],
+    });
+    let view = target.create_view(&Default::default());
+    let readback = device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some("draw-order readback"),
+        size: (SIZE * SIZE * 4) as u64,
+        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+        mapped_at_creation: false,
+    });
+    pipeline.ensure_depth_texture(device, Size::new(SIZE, SIZE));
+    pipeline.upload_uniforms(device, queue, uniforms);
+    pipeline.gpu_wires = std::sync::Arc::new(WireGpu::from_batch(
+        device,
+        queue,
+        wires,
+        depths,
+        pipeline.wire_const_bgl.as_ref(),
+    ));
+    let mut encoder = device.create_command_encoder(&Default::default());
+    let rect = Rectangle {
+        x: 0,
+        y: 0,
+        width: SIZE,
+        height: SIZE,
+    };
+    pipeline.render(
+        &mut encoder,
+        &view,
+        Rectangle::with_size(Size::new(SIZE as f32, SIZE as f32)),
+        rect,
+        rect,
+        [0., 0., 0., 1.],
+        false,
+        false,
+        false,
+    );
+    encoder.copy_texture_to_buffer(
+        wgpu::TexelCopyTextureInfo {
+            texture: &target,
+            mip_level: 0,
+            origin: wgpu::Origin3d::ZERO,
+            aspect: wgpu::TextureAspect::All,
+        },
+        wgpu::TexelCopyBufferInfo {
+            buffer: &readback,
+            layout: wgpu::TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(SIZE * 4),
+                rows_per_image: Some(SIZE),
+            },
+        },
+        size,
+    );
+    queue.submit([encoder.finish()]);
+    let (tx, rx) = std::sync::mpsc::channel();
+    readback.slice(..).map_async(wgpu::MapMode::Read, move |r| {
+        tx.send(r).unwrap();
+    });
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+    rx.recv().unwrap().unwrap();
+    let result = readback.slice(..).get_mapped_range().to_vec();
+    readback.unmap();
+    result
+}
+
+fn color_at(bytes: &[u8], ndc_x: f32) -> [u32; 3] {
+    let x = ((ndc_x * 0.5 + 0.5) * SIZE as f32) as usize;
+    let mut color = [0; 3];
+    for col in x - 2..=x + 2 {
+        let offset = (SIZE as usize / 2 * SIZE as usize + col) * 4;
+        for c in 0..3 {
+            color[c] += bytes[offset + c] as u32;
+        }
+    }
+    color
+}
+
+#[test]
+#[ignore = "requires a GPU adapter"]
+fn perspective_draw_order_keeps_flat_lines_visible() {
+    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+    let adapter = block_on(instance.request_adapter(&Default::default())).expect("GPU adapter");
+    let bounds = Rectangle::with_size(Size::new(SIZE as f32, SIZE as f32));
+    let mut failures = Vec::new();
+    for packed in [false, true] {
+        let mut limits = adapter.limits();
+        if packed {
+            limits.max_storage_buffers_per_shader_stage = 0;
+        }
+        let (device, queue) = block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+            required_limits: limits,
+            ..Default::default()
+        }))
+        .expect("GPU device");
+        let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let mut pipeline = Pipeline::new(&device, &queue, wgpu::TextureFormat::Rgba8Unorm);
+        for projection in [Projection::Orthographic, Projection::Perspective] {
+            let camera = Camera {
+                distance: 102.03651,
+                fov_y: 0.47108996,
+                rotation: glam::Quat::IDENTITY,
+                target: glam::DVec3::ZERO,
+                projection,
+                ..Camera::default()
+            };
+            // Same 17-entity draw-order labels as the reported drawing. Its
+            // missing line (45EB) occupies index 1 with depth -0.5794896.
+            let depths = (0..17)
+                .map(|i| {
+                    (
+                        i + 1,
+                        [
+                            (-800_000_000_i64 + 88_888_888 * (i + 1) as i64) as f32
+                                / 1_073_741_824.,
+                            0.,
+                        ],
+                    )
+                })
+                .collect();
+            let wires: Vec<_> = (0..17)
+                .map(|i| {
+                    let x = (-0.8 + i as f32 * 0.1) * camera.ortho_size();
+                    let h = camera.ortho_size() * 0.65;
+                    WireModel::solid(
+                        (i + 1).to_string(),
+                        vec![[x, -h, 0.], [x, h, 0.]],
+                        if i < 2 { [1., 0.3, 0.2, 1.] } else { [1.; 4] },
+                        false,
+                    )
+                })
+                .collect();
+            let bytes = pixels(
+                &device,
+                &queue,
+                &mut pipeline,
+                &Uniforms::new(&camera, bounds, false),
+                &wires,
+                &depths,
+            );
+            if let Ok(path) = std::env::var("OCS_DEPTH_TEST_IMAGES") {
+                let path = std::path::Path::new(&path);
+                std::fs::create_dir_all(path).unwrap();
+                image::save_buffer(
+                    path.join(format!(
+                        "{projection:?}-{}.png",
+                        if packed { "packed" } else { "storage" }
+                    )),
+                    &bytes,
+                    SIZE,
+                    SIZE,
+                    image::ColorType::Rgba8,
+                )
+                .unwrap();
+            }
+            for i in 0..17 {
+                if color_at(&bytes, -0.8 + i as f32 * 0.1) == [0; 3] {
+                    failures.push(format!("{projection:?}, packed={packed}, line {i}"));
+                }
+            }
+        }
+        assert!(
+            block_on(validation.pop()).is_none(),
+            "GPU validation failed"
+        );
+    }
+    assert!(
+        failures.is_empty(),
+        "visible lines were clipped: {failures:?}"
+    );
+}
+
+#[test]
+fn all_draw_order_shaders_validate() {
+    for source in [
+        draw_order_shader!("wire.wgsl"),
+        draw_order_shader!("wire_indexed.wgsl"),
+        draw_order_shader!("block_wire.wgsl"),
+        draw_order_shader!("block_wire_storage.wgsl"),
+        draw_order_shader!("circle.wgsl"),
+        draw_order_shader!("ellipse.wgsl"),
+        draw_order_shader!("text.wgsl"),
+        draw_order_shader!("block_text.wgsl"),
+        draw_order_shader!("face3d.wgsl"),
+        draw_order_shader!("block_face3d.wgsl"),
+        draw_order_shader!("hatch.wgsl"),
+        draw_order_shader!("hatch_texture.wgsl"),
+        draw_order_shader!("image.wgsl"),
+        draw_order_shader!("wipeout.wgsl"),
+    ] {
+        let module = naga::front::wgsl::parse_str(source).expect("composed shader parses");
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .expect("composed shader validates");
+    }
+}
+
+#[test]
+#[ignore = "requires a GPU adapter"]
+fn draw_order_preserves_clip_boundaries_sorting_and_mesh_occlusion() {
+    use crate::scene::model::mesh_model::{MeshLodSet, MeshModel};
+    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+    let adapter = block_on(instance.request_adapter(&Default::default())).expect("GPU adapter");
+    for packed in [false, true] {
+        let mut limits = adapter.limits();
+        if packed {
+            limits.max_storage_buffers_per_shader_stage = 0;
+        }
+        let (device, queue) = block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+            required_limits: limits,
+            ..Default::default()
+        }))
+        .expect("GPU device");
+        let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let mut pipeline = Pipeline::new(&device, &queue, wgpu::TextureFormat::Rgba8Unorm);
+        let bounds = Rectangle::with_size(Size::new(SIZE as f32, SIZE as f32));
+        let mut uniforms = Uniforms::new(&Camera::default(), bounds, false);
+        uniforms.view_rot = glam::Mat4::IDENTITY;
+        uniforms.eye_high = [0.; 3];
+        uniforms.eye_low = [0.; 3];
+        let line = |id: u64, x: f32, z: f32, color: [f32; 4]| {
+            WireModel::solid(
+                id.to_string(),
+                vec![[x, -0.65, z], [x, 0.65, z]],
+                color,
+                false,
+            )
+        };
+        // Both bias signs, the paper's -2 order, and already-clipped geometry.
+        let cases = [
+            (0.00001, 2., true),
+            (0.00001, -2., true),
+            (0.99999, 2., true),
+            (0.99999, -2., true),
+            (-0.00001, -2., false),
+            (1.00001, 2., false),
+            (0., 2., true),
+            (1., -2., true),
+            (0.5, 0., true),
+        ];
+        let wires: Vec<_> = cases
+            .iter()
+            .enumerate()
+            .map(|(i, (z, _, _))| line(i as u64 + 1, -0.8 + i as f32 * 0.2, *z, [1.; 4]))
+            .collect();
+        let depths = cases
+            .iter()
+            .enumerate()
+            .map(|(i, (_, order, _))| (i as u64 + 1, [*order, 0.]))
+            .collect();
+        let bytes = pixels(&device, &queue, &mut pipeline, &uniforms, &wires, &depths);
+        for (i, (z, order, visible)) in cases.iter().enumerate() {
+            assert_eq!(
+                color_at(&bytes, -0.8 + i as f32 * 0.2) != [0; 3],
+                *visible,
+                "packed={packed}, depth={z}, order={order}"
+            );
+        }
+
+        // Coplanar draw order must work close to both planes, for negative
+        // ranks too, regardless of the order in which the GPU sees the wires.
+        for z in [0.0001, 0.5, 0.9999] {
+            for (back, front) in [(-0.7, 0.7), (-2., -0.9), (0.3, 0.8)] {
+                let depths = rustc_hash::FxHashMap::from_iter([(1, [back, 0.]), (2, [front, 0.])]);
+                let mut wires = [
+                    line(1, 0., z, [1., 0., 0., 1.]),
+                    line(2, 0., z, [0., 1., 0., 1.]),
+                ];
+                for _ in 0..2 {
+                    let bytes = pixels(&device, &queue, &mut pipeline, &uniforms, &wires, &depths);
+                    let [red, green, _] = color_at(&bytes, 0.);
+                    assert!(
+                        green > 0 && red == 0,
+                        "draw order reversed at z={z}, packed={packed}"
+                    );
+                    wires.reverse();
+                }
+            }
+        }
+
+        // A real triangle mesh still occludes a wire behind it. A wire in front
+        // stays visible: neutral draw order must retain geometric depth.
+        pipeline.upload_mesh_batch(
+            &device,
+            &queue,
+            &[MeshLodSet::from_single(MeshModel {
+                name: "100".into(),
+                verts: vec![
+                    [-0.6, -0.8, 0.5],
+                    [0.6, -0.8, 0.5],
+                    [0.6, 0.8, 0.5],
+                    [-0.6, 0.8, 0.5],
+                ],
+                verts_low: Vec::new(),
+                normals: vec![[0., 0., 1.]; 4],
+                indices: vec![0, 1, 2, 0, 2, 3],
+                triangle_material_handles: Vec::new(),
+                triangle_colors: Vec::new(),
+                color: [0., 1., 0., 1.],
+                selected: false,
+            })],
+        );
+        let mesh_only = pixels(
+            &device,
+            &queue,
+            &mut pipeline,
+            &uniforms,
+            &[],
+            &Default::default(),
+        );
+        assert_ne!(
+            color_at(&mesh_only, -0.3),
+            [0; 3],
+            "mesh must produce pixels"
+        );
+        let bytes = pixels(
+            &device,
+            &queue,
+            &mut pipeline,
+            &uniforms,
+            &[
+                line(1, -0.3, 0.6, [1., 0., 0., 1.]),
+                line(2, 0.3, 0.4, [0., 0., 1., 1.]),
+            ],
+            &Default::default(),
+        );
+        assert_eq!(
+            color_at(&bytes, -0.3),
+            color_at(&mesh_only, -0.3),
+            "mesh failed to occlude the rear wire, packed={packed}"
+        );
+        let [red, _, blue] = color_at(&bytes, 0.3);
+        assert!(blue > red, "mesh hid the front wire, packed={packed}");
+        assert!(
+            block_on(validation.pop()).is_none(),
+            "GPU validation failed"
+        );
+    }
+}