use crate::scene::dynamic_gi::ProbePlacement;
use crate::scene::rays::acceleration::RayTracingStats;
use crate::settings::WorldSpaceReflections;
use crate::shading::uniforms::{FrameValues, ViewUniform};
use crate::view::clusters::{BoxVolume, CAMERA_CLUSTERS, Clusters, ViewVolume};
use crate::view::draw_list::gpu::{camera_cull, cascade_cull};
use crate::view::draw_list::{DrawInstances, DrawList};
use crate::view::effective::{Effective, HardwareRayTracing};
use crate::view::frame::FrameContext;
use crate::view::history::HistoryFrame;
use crate::view::population::Population;
use crate::view::reflection_camera;
use crate::view::{FrameShadow, FrameViews, Jitter, View, frame_uniform, lod::LodSelector};
use crate::{FrameInput, Scene};
use glam::{Mat4, Vec3};
pub(crate) struct CaptureViews {
pub frame: wgpu::Buffer,
pub faces: Vec<wgpu::Buffer>,
pub cascades: Vec<wgpu::Buffer>,
pub casters: DrawList,
pub list: DrawList,
pub instances: DrawInstances,
pub clusters: Clusters,
}
pub(crate) fn set_cascades(
(device, queue): (&wgpu::Device, &wgpu::Queue),
scene: &Scene,
views: &mut FrameViews,
mask: u32,
clip_from_world: impl ExactSizeIterator<Item = Mat4>,
) {
views.cascade_count = clip_from_world.len();
for (slot, clip_from_world) in views.cascades.iter_mut().zip(clip_from_world) {
let view = View::shadow_cascade(clip_from_world);
slot.set(queue, view);
let started = crate::counters::Moment::now();
slot.list
.prepare(device, queue, scene, cascade_cull(&view, mask), false);
slot.built(started);
}
}
const NO_RAY_QUERIES: &str = "the device has no hardware ray queries: the browser's WebGPU \
has none, and a native device has them where its adapter does and the game requested \
graphics_device::ray_tracing_features";
const NO_MEMORY: &str = "the device's memory could not hold the scene's TLAS";
#[derive(Default)]
pub(crate) struct Prepare {
ray_tracing: RayTracingStats,
hardware_rays: bool,
ray_tracing_error: Option<&'static str>,
hardware_requested: bool,
}
impl Prepare {
#[allow(clippy::too_many_arguments)]
pub fn run(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
scene: &mut Scene,
input: &FrameInput,
history: HistoryFrame,
effective: &Effective,
jitter: Option<Jitter>,
render_size: [u32; 2],
views: &mut FrameViews,
frame_buffer: &wgpu::Buffer,
) -> FrameValues {
let camera = input.camera;
let stable = history.stable;
let mut view = ViewUniform {
view: camera.view.to_cols_array_2d(),
projection: camera.projection.to_cols_array_2d(),
view_projection: stable.to_cols_array_2d(),
inverse_view_projection: stable.inverse().to_cols_array_2d(),
stable_view_projection: stable.to_cols_array_2d(),
previous_view_projection: history.previous.to_cols_array_2d(),
eye: camera.eye.to_array(),
mip_bias: 0.,
jitter: [0.; 2],
viewport: [render_size[0] as f32, render_size[1] as f32],
flags: 0,
padding: [0; 3],
};
let shadow = FrameShadow::camera(
input,
effective.shadow_quality.cascade_size(),
effective.shadow_filter,
history.frames,
scene.origin(),
);
let volume = scene
.dynamic_gi_placement()
.filter(|_| effective.dynamic_gi.is_some());
let mut frame = frame_uniform(
input,
(&scene.static_lighting, scene.irradiance_volume()),
&shadow,
effective.fog.is_some(),
volume.as_ref(),
);
frame.previous_elapsed_seconds = history.previous_elapsed_seconds as f32;
frame.previous_animation_phase =
crate::shading::material::animation_phase(history.previous_elapsed_seconds);
views.reflection_camera = reflection_camera::Camera::new(camera.view, camera.projection);
if let Some(jitter) = jitter {
let projection = history.camera.jittered_projection();
let raster = projection * camera.view;
view.view_projection = raster.to_cols_array_2d();
view.inverse_view_projection = raster.inverse().to_cols_array_2d();
view.jitter = [jitter.ndc[0] / 2., jitter.ndc[1] / 2.];
view.mip_bias = jitter.mip_bias;
views.reflection_camera = reflection_camera::Camera::new(camera.view, projection);
}
let values = FrameValues { view, frame };
crate::counters::write_buffer(queue, frame_buffer, 0, bytemuck::bytes_of(&frame));
views.camera.set(queue, View::camera(view));
scene.prepare_frame(device, queue, camera.eye);
let world_space = effective.world_space != WorldSpaceReflections::Off;
let traced = world_space || volume.is_some() || effective.ray_traced_shadows;
self.ray_tracing = RayTracingStats::default();
self.hardware_rays = false;
self.hardware_requested =
matches!(effective.hardware_ray_tracing, HardwareRayTracing::On(_));
match effective.hardware_ray_tracing {
HardwareRayTracing::Off | HardwareRayTracing::Unsupported => {
scene.free_acceleration_structures();
self.ray_tracing_error = (effective.hardware_ray_tracing
== HardwareRayTracing::Unsupported)
.then_some(NO_RAY_QUERIES);
}
HardwareRayTracing::On(form) if traced => {
let prepared =
scene.prepare_acceleration_structures(device, queue, camera.eye, form);
self.hardware_rays = prepared.is_some();
self.ray_tracing = prepared.unwrap_or_default();
self.ray_tracing_error = prepared.is_none().then_some(NO_MEMORY);
}
HardwareRayTracing::On(_) => scene.skip_acceleration_structures(),
}
if traced {
scene.update_rays(device, queue, frame.visibility_mask, self.hardware_rays);
}
let scene = &*scene;
views.clusters.cluster(
device,
queue,
&scene.lights,
effective.local_lights,
&scene.decals,
camera.view,
camera.projection,
render_size,
CAMERA_CLUSTERS,
);
if world_space {
let volume = ViewVolume::new(camera.projection * camera.view);
views.ray_lists.list(
device,
queue,
&scene.lights,
effective.local_lights,
|light| volume.reaches(light),
&scene.decals,
|decal| volume.reaches_decal(decal),
);
}
if let Some(volume) = volume {
let extent = BoxVolume {
min: volume.volume.origin,
max: volume.volume.end(),
};
views.volume_lists.list(
device,
queue,
&scene.lights,
effective.local_lights,
|light| extent.reaches(light),
&scene.decals,
|decal| extent.reaches_decal(decal),
);
}
let mask = frame.visibility_mask;
views.instances.clear();
let camera_view = views.camera.view;
let cull = effective.culling;
let started = crate::counters::Moment::now();
let mut camera_cull = camera_cull(&camera_view, render_size, mask, cull);
if world_space {
camera_cull.flags &= !crate::shading::culling::CULL_LOD;
}
views.camera.list.prepare(
device,
queue,
scene,
camera_cull,
effective.occlusion_culling,
);
views.camera.built(started);
let lod = if world_space {
None
} else {
LodSelector::new(camera.view, camera.projection, render_size)
};
views.blended.build(
&mut views.instances,
scene,
&camera_view,
Some(mask),
Population::Blended { lod, cull },
);
let cascades = shadow.cascades.as_slice().iter();
set_cascades(
(device, queue),
scene,
views,
mask,
cascades.map(|cascade| cascade.clip_from_world),
);
values
}
pub fn encode_acceleration_structures(&self, ctx: &mut FrameContext<'_>) {
ctx.scene.encode_acceleration_structures(ctx.encoder);
}
pub fn ray_tracing_stats(&self) -> RayTracingStats {
self.ray_tracing
}
pub fn hardware_rays(&self) -> bool {
self.hardware_rays
}
pub fn ray_tracing_error(&self) -> Option<&'static str> {
self.ray_tracing_error
}
pub fn hardware_requested(&self) -> bool {
self.hardware_requested
}
#[allow(clippy::too_many_arguments)]
pub fn capture(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
scene: &Scene,
input: &FrameInput,
local_lights: bool,
center: Vec3,
cascade_size: u32,
dynamic_gi: Option<&ProbePlacement>,
) -> CaptureViews {
let shadow = FrameShadow::capture(input, center, cascade_size, scene.origin());
let frame = frame_uniform(
input,
(&scene.static_lighting, scene.irradiance_volume()),
&shadow,
false,
dynamic_gi,
);
let uniform = |label, bytes: &[u8]| {
crate::scene::buffer(device, label, bytes, wgpu::BufferUsages::UNIFORM)
};
let frame_buffer = uniform("static capture frame", bytemuck::bytes_of(&frame));
let views: Vec<_> = (0..6).map(|face| View::probe_face(center, face)).collect();
let faces = views
.iter()
.map(|view| uniform("static capture camera", bytemuck::bytes_of(&view.uniform)))
.collect();
let mask = Some(frame.visibility_mask);
let cascades: Vec<_> = shadow
.cascades
.as_slice()
.iter()
.map(|cascade| View::shadow_cascade(cascade.clip_from_world))
.collect();
let mut instances = DrawInstances::default();
let mut casters = DrawList::default();
if let Some(cascade) = cascades.first() {
casters.build(
&mut instances,
scene,
cascade,
mask,
Population::CaptureShadow,
);
}
let cascades = cascades
.iter()
.map(|cascade| {
uniform(
"static capture shadow cascade",
bytemuck::bytes_of(&cascade.uniform),
)
})
.collect();
let mut list = DrawList::default();
list.build(
&mut instances,
scene,
&views[0],
mask,
Population::ProbeFace,
);
let mut clusters = Clusters::new(device, "static capture lights and decals");
clusters.list(
device,
queue,
&scene.lights,
local_lights,
|_| true,
&scene.decals,
|_| true,
);
CaptureViews {
frame: frame_buffer,
faces,
cascades,
casters,
list,
instances,
clusters,
}
}
}