use crate::asset::{Asset, Image};
use crate::graphics_device::BindingTier;
use crate::renderer::test_frame::TestRenderer;
use crate::settings::{self, DynamicGiQuality, Settings};
use crate::shading::gbuffer;
use crate::{
AlphaMode, Camera, DynamicGiVolume, FrameInput, InstanceState, IrradianceVolume, Mobility,
Scene, test_support,
};
use glam::{Mat4, Vec3};
const EXTENDED_SAMPLED_TEXTURES: u32 = 48;
#[test]
fn a_device_at_webgpus_default_limits_runs_every_pipeline() {
let (tier, dynamic_gi) = heaviest_frame(wgpu::Limits::default());
assert_eq!(tier, BindingTier::Basic);
assert_eq!(dynamic_gi, DynamicGiQuality::Off);
}
#[test]
fn a_device_at_the_extended_threshold_binds_the_extended_tier() {
let limits = wgpu::Limits {
max_sampled_textures_per_shader_stage: EXTENDED_SAMPLED_TEXTURES,
..wgpu::Limits::default()
};
let (tier, dynamic_gi) = heaviest_frame(limits);
assert_eq!(tier, BindingTier::Extended);
assert_eq!(dynamic_gi, DynamicGiQuality::High);
}
fn heaviest_frame(limits: wgpu::Limits) -> (BindingTier, DynamicGiQuality) {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::NOOP,
backend_options: wgpu::BackendOptions {
noop: wgpu::NoopBackendOptions {
enable: true,
limits: Some(limits.clone()),
features: Some(wgpu::Features::empty()),
..Default::default()
},
..Default::default()
},
..wgpu::InstanceDescriptor::new_without_display_handle()
});
let adapter = pollster::block_on(instance.request_adapter(&Default::default())).unwrap();
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
required_limits: limits,
..Default::default()
}))
.unwrap();
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
let settings = Settings {
antialiasing: settings::Antialiasing::Taa,
screen_space_reflections: settings::ScreenSpaceReflections::Full,
world_space_reflections: settings::WorldSpaceReflections::Moving,
dynamic_gi: DynamicGiQuality::High,
ambient_occlusion: settings::AmbientOcclusionQuality::High,
screen_space_indirect: settings::ScreenSpaceIndirect::High,
atmosphere: true,
contact_shadows: settings::ContactShadows::Long,
..Settings::default()
};
let size = [32, 32];
let mut renderer = TestRenderer::for_test(&device, &queue, size, &settings);
let mut scene = Scene::new(&device, &queue);
let shader = test_support::add_test_shader(&mut scene);
let mut wall = test_support::cube();
wall.materials[0].alpha = AlphaMode::Mask { cutoff: 0.5 };
let wall = scene.add_asset(&device, &queue, wall).unwrap();
let normal_glass = scene.add_asset(&device, &queue, glass(true)).unwrap();
let bump_glass = scene.add_asset(&device, &queue, glass(false)).unwrap();
for material in [wall.materials[0], bump_glass.materials[0]] {
test_support::set_shader(&mut scene, &queue, material, (shader, 0.));
}
for (model, at, mobility) in [
(wall.model, Vec3::new(0.3, 0., -4.), Mobility::Static),
(
normal_glass.model,
Vec3::new(0.3, 0., -2.),
Mobility::Moving,
),
(
bump_glass.model,
Vec3::new(-0.5, 0., -2.5),
Mobility::Moving,
),
] {
scene
.add_instance(
&device,
&queue,
InstanceState {
pose: Mat4::from_translation(at),
..InstanceState::new(model)
},
mobility,
)
.unwrap();
}
scene
.set_dynamic_gi_volume(
&device,
Some(DynamicGiVolume {
origin: Vec3::splat(-3.),
spacing: Vec3::splat(2.),
probes: [4, 4, 4],
}),
)
.unwrap();
scene
.set_irradiance_volume(
&device,
&queue,
Some(IrradianceVolume {
origin: Vec3::splat(-4.),
cell_size: Vec3::ONE,
cells: [8, 8, 8],
}),
)
.unwrap();
let mut input = FrameInput::new(Camera {
view: Mat4::IDENTITY,
projection: crate::perspective(1., 1., 0.1),
eye: Vec3::ZERO,
});
input.atmosphere = true;
input.fog.density = 0.05;
input.environment = crate::FrameEnvironment::Sky(crate::Sky::default());
input.directional_lights[0] = Some(crate::DirectionalLight {
direction: Vec3::new(0.3, -1., -0.4),
shadow: Some(crate::DirectionalShadow::DEFAULT),
..crate::DirectionalLight::default()
});
let output = crate::view::targets::target(&device, "floor", size, gbuffer::COLOR);
for _ in 0..2 {
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
&device,
&queue,
&mut encoder,
&mut scene,
&input,
&settings,
&output,
None,
);
queue.submit([encoder.finish()]);
renderer.finish_frame(&mut scene);
}
if let Some(error) = pollster::block_on(validation.pop()) {
panic!("{error}");
}
(
renderer.binding_tier(),
renderer.dynamic_gi_in_effect(&settings, &scene),
)
}
fn glass(normal: bool) -> Asset {
let mut glass = test_support::cube();
for vertex in &mut glass.meshes[0].vertices {
let tangent = Vec3::from_array(vertex.normal).any_orthonormal_vector();
vertex.tangent = tangent.extend(1.).to_array();
}
glass.images = (0..17)
.map(|_| Image::Rgba8(image::RgbaImage::from_pixel(4, 4, image::Rgba([200; 4]))))
.collect();
let material = &mut glass.materials[0];
material.alpha = AlphaMode::Blend {
receives_screen_space_reflections: true,
keeps_specular: false,
};
material.base[3] = 0.5;
material.base_texture = Some(0);
material.mr_texture = Some(1);
material.occlusion_texture = Some(1);
material.emissive_texture = Some(2);
if normal {
material.normal_texture = Some(3);
} else {
material.bump_texture = Some(4);
material.bump_scale = 1.;
}
material.anisotropy_texture = Some(5);
material.anisotropy_strength = 0.5;
material.clearcoat = 0.5;
material.clearcoat_texture = Some(6);
material.coat_roughness_texture = Some(7);
material.coat_normal_texture = Some(8);
material.iridescence = 0.5;
material.iridescence_texture = Some(9);
material.iridescence_thickness_texture = Some(10);
material.metallic = 0.;
material.transmission = 1.;
material.transmission_texture = Some(11);
material.thickness = 0.2;
material.thickness_texture = Some(12);
material.attenuation_distance = 1.;
material.attenuation_color = [0.8, 0.9, 1.];
material.dispersion = 0.5;
material.sheen_color = [0.5; 3];
material.sheen_color_texture = Some(13);
material.sheen_roughness_texture = Some(14);
material.diffuse_transmission = 0.5;
material.diffuse_transmission_texture = Some(15);
material.diffuse_transmission_color_texture = Some(14);
glass
}