use super::*;
pub(super) async fn verify_scissor_edges(
device: &wgpu::Device,
queue: &wgpu::Queue,
format: wgpu::TextureFormat,
production_samples: u32,
) {
let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
let identity = Arc::new(());
let image = create_image_resources(
device,
queue,
Arc::clone(&identity),
1,
1,
vec![255; 4],
ImageBudget::default(),
)
.unwrap();
let viewport = LogicalViewport::new(64.0, 64.0).unwrap();
let sprite = ImageSprite2d::new(
image.full_rect(),
LogicalViewportRegion::new(LogicalScreenPosition::new(0.0, 0.0), viewport).unwrap(),
Color::WHITE.with_alpha(0.5),
)
.unwrap();
let batch = create_image_batch_resources(
device,
queue,
identity,
&image,
vec![sprite],
ImageBatchBudget::new(1, batch_retained_bytes(1)).unwrap(),
)
.unwrap();
let clip = ScreenClipRect::from_min_size(
LogicalScreenPosition::new(24.0, 18.0),
crate::LogicalScreenVector::new(6.0, 10.0),
)
.unwrap();
for samples in std::iter::once(1).chain((production_samples != 1).then_some(production_samples))
{
for (physical, expected_scissor) in [(64_u32, (24, 18, 6, 10)), (80_u32, (30, 22, 8, 13))] {
let scale = physical as f32 / 64.0;
let scissor = screen_clip_to_scissor(clip, viewport, scale).unwrap();
assert_eq!(
(scissor.x, scissor.y, scissor.width, scissor.height),
expected_scissor,
"physical scissor rounding changed at scale {scale}"
);
let pixels = render_scissored_batch(
device, queue, &image, &batch, format, samples, physical, scissor,
)
.await;
let stride = (physical as usize * 4).div_ceil(256) * 256;
let (red, green, blue) = if matches!(
format,
wgpu::TextureFormat::Bgra8Unorm | wgpu::TextureFormat::Bgra8UnormSrgb
) {
(2, 1, 0)
} else {
(0, 1, 2)
};
let quarter = if format.is_srgb() {
((1.055 * 0.25_f32.powf(1.0 / 2.4) - 0.055) * 255.0).round() as u8
} else {
(0.25_f32 * 255.0).round() as u8
};
for y in 0..physical {
for x in 0..physical {
let inside = x >= scissor.x
&& x < scissor.x + scissor.width
&& y >= scissor.y
&& y < scissor.y + scissor.height;
let start = y as usize * stride + x as usize * 4;
let actual = [
pixels[start + red],
pixels[start + green],
pixels[start + blue],
];
let expected_green = if inside { quarter } else { 0 };
let tolerance = if inside { 3 } else { 0 };
assert!(
actual[0] == 0
&& actual[1].abs_diff(expected_green) <= tolerance
&& actual[2] == 0
&& pixels[start + 3] == 255,
"scissor pixel physical=({x}, {y}) logical_center=({}, {}) \
target={physical}x{physical} scale={scale} format={format:?} \
samples={samples} scissor={scissor:?}: rgba={:?}, \
expected=[0, {expected_green}, 0, 255]; green physical row={:?}",
(x as f32 + 0.5) / scale,
(y as f32 + 0.5) / scale,
[actual[0], actual[1], actual[2], pixels[start + 3]],
(0..physical as usize)
.map(|column| pixels[y as usize * stride + column * 4 + green])
.collect::<Vec<_>>()
);
}
}
}
}
assert!(scope.pop().await.is_none());
}
#[allow(clippy::too_many_arguments)]
async fn render_scissored_batch(
device: &wgpu::Device,
queue: &wgpu::Queue,
image: &Image2d,
batch: &ImageBatch2d,
format: wgpu::TextureFormat,
samples: u32,
physical: u32,
scissor: ScissorRect,
) -> Vec<u8> {
let renderer = ImageRenderer::new(device, format, samples);
let size = wgpu::Extent3d {
width: physical,
height: physical,
depth_or_array_layers: 1,
};
let descriptor = wgpu::TextureDescriptor {
label: Some("image batch scissor oracle"),
size,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
};
let target = device.create_texture(&descriptor);
let target_view = target.create_view(&Default::default());
let multisampled = (samples > 1).then(|| {
device.create_texture(&wgpu::TextureDescriptor {
sample_count: samples,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
..descriptor
})
});
let multisampled_view = multisampled
.as_ref()
.map(|texture| texture.create_view(&Default::default()));
let uniform = batch_uniform(
LogicalViewport::new(64.0, 64.0).unwrap(),
Vec2::ZERO,
ImageBatchPlacement::new(
crate::LogicalScreenVector::default(),
Color::rgba(0.0, 1.0, 0.0, 0.5),
)
.unwrap(),
)
.unwrap();
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("scissor oracle placement uniform"),
size: std::mem::size_of::<ImageUniform>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
queue.write_buffer(&buffer, 0, bytemuck::bytes_of(&uniform));
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("scissor oracle placement binding"),
layout: &renderer.bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&image.view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(renderer.sampler(ImageSampling::Nearest)),
},
wgpu::BindGroupEntry {
binding: 2,
resource: buffer.as_entire_binding(),
},
],
});
let stride = (physical as usize * 4).div_ceil(256) * 256;
let readback = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("image batch scissor pixels"),
size: (stride * physical as usize) as u64,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = device.create_command_encoder(&Default::default());
{
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("single-pass image scissor oracle"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: multisampled_view.as_ref().unwrap_or(&target_view),
depth_slice: None,
resolve_target: multisampled_view.as_ref().map(|_| &target_view),
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: wgpu::StoreOp::Store,
},
})],
depth_stencil_attachment: None,
timestamp_writes: None,
occlusion_query_set: None,
multiview_mask: None,
});
pass.set_pipeline(&renderer.batch_pipeline);
pass.set_bind_group(0, &bind_group, &[]);
pass.set_vertex_buffer(0, batch.instance_buffer.slice(..));
pass.set_scissor_rect(scissor.x, scissor.y, scissor.width, scissor.height);
pass.draw(0..6, 0..1);
}
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(stride as u32),
rows_per_image: Some(physical),
},
},
size,
);
queue.submit([encoder.finish()]);
read_buffer(device, &readback).await
}