forked from 1b-agent/opencadstudio-upstream
371 lines
13 KiB
Rust
371 lines
13 KiB
Rust
//! 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"
|
|
);
|
|
}
|
|
}
|