use crate::InstanceId;
use crate::content::identity::Identity;
pub use crate::counters::{BuildStep, Counters, StepTime, UploadSite};
pub use crate::scene::SceneResources;
pub use crate::stages::dynamic_gi::DynamicGiChanges;
pub fn counters() -> Counters {
crate::counters::snapshot()
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ViewDraws {
pub camera: usize,
pub blended: usize,
pub cascades: Vec<usize>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ViewTimes {
pub camera: ViewTime,
pub cascades: Vec<ViewTime>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct ViewTime {
pub build_ms: f64,
pub encode_ms: f64,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct DynamicGiReport {
pub frame: u64,
pub skipped: u32,
pub probes: u32,
pub traced_probes: u32,
pub unblended_probes: u32,
pub blended_requests: u32,
pub stride: u32,
pub probes_by_rays: [u32; 8],
pub rays: u32,
pub fixed_rays: u32,
pub hits: u32,
pub visibility_rays: u32,
pub ray_visits: u64,
pub most_ray_visits: u32,
pub visibility_visits: u64,
pub most_visibility_visits: u32,
pub exhausted_queries: u32,
pub paused: bool,
pub converged: bool,
pub changes: DynamicGiChanges,
pub scrolled: [i32; 3],
pub moving_bounds: u32,
}
pub fn source_id(instance: InstanceId) -> u32 {
instance.index() as u32 + 1
}
pub fn crystal_roughness_threshold() -> f32 {
crate::view::post_fx::ssr_attribs().roughness_threshold
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DiagnosticTarget {
Depth,
Normal,
Motion,
SourceId,
Composite,
AmbientOcclusion,
ToneMapped,
Exposure,
}
pub fn read(
device: &wgpu::Device,
queue: &wgpu::Queue,
texture: &wgpu::Texture,
bpp: u32,
) -> Vec<u8> {
let size = texture.size();
let row = (size.width * bpp).div_ceil(256) * 256;
let buffer = crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("frame evidence"),
size: u64::from(row * size.height),
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
);
let mut encoder = device.create_command_encoder(&Default::default());
encoder.copy_texture_to_buffer(
texture.as_image_copy(),
wgpu::TexelCopyBufferInfo {
buffer: &buffer,
layout: wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(row),
rows_per_image: Some(size.height),
},
},
size,
);
queue.submit([encoder.finish()]);
let (tx, rx) = std::sync::mpsc::channel();
buffer.map_async(wgpu::MapMode::Read, .., move |r| {
tx.send(r).unwrap();
});
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
rx.recv().unwrap().unwrap();
let mapped = buffer.get_mapped_range(..).expect("mapped readback");
let mut pixels = Vec::new();
for line in mapped.chunks(row as usize) {
pixels.extend_from_slice(&line[..(size.width * bpp) as usize]);
}
pixels
}
pub fn half(bytes: &[u8]) -> f32 {
let bits = u16::from_le_bytes([bytes[0], bytes[1]]);
let sign = if bits & 0x8000 == 0 { 1.0 } else { -1.0 };
let exponent = ((bits >> 10) & 31) as i32;
let fraction = (bits & 1023) as f32;
sign * if exponent == 0 {
fraction * 2f32.powi(-24)
} else if exponent == 31 {
if fraction == 0. {
f32::INFINITY
} else {
f32::NAN
}
} else {
(1. + fraction / 1024.) * 2f32.powi(exponent - 15)
}
}