use super::gpu::GpuTexture;
use super::gpu3d::*;
use crate::three::{Frame3D, GpuMaterialDesc, Scene3D, SkinFrame, SkyLight};
use crate::*;
const SIZE: u32 = 128;
struct Rig {
device: wgpu::Device,
queue: wgpu::Queue,
output: wgpu::Texture,
target: wgpu::TextureView,
textures: Vec<GpuTexture>,
renderer: Renderer3D,
ctx: Ctx,
}
impl Rig {
fn new() -> Option<Self> {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
let Ok(adapter) = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())) else {
eprintln!("no GPU adapter: skipped");
return None;
};
let Ok((device, queue)) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())) else {
eprintln!("no GPU device: skipped");
return None;
};
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None,
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
let white = device.create_texture(&wgpu::TextureDescriptor {
label: None,
size: wgpu::Extent3d {
width: 1,
height: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[wgpu::TextureFormat::Rgba8Unorm],
});
queue.write_texture(
white.as_image_copy(),
&[255; 4],
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(4),
rows_per_image: None,
},
white.size(),
);
let sampler = device.create_sampler(&Default::default());
let view = white.create_view(&Default::default());
let textures = vec![GpuTexture {
texture: white.clone(),
nearest: false,
mips: None,
bind_group: device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None,
layout: &layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&sampler),
},
],
}),
}];
let output = device.create_texture(&wgpu::TextureDescriptor {
label: None,
size: wgpu::Extent3d {
width: SIZE,
height: SIZE,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
});
let target = output.create_view(&Default::default());
let renderer = Renderer3D::new(&device, &layout, output.format(), 0, &white, 4, true);
let mut ctx = Ctx::new(1.0 / 60.0, Vec2::new(SIZE as f32, SIZE as f32));
ctx.sky.atmosphere = false;
Some(Self {
device,
queue,
output,
target,
textures,
renderer,
ctx,
})
}
fn mesh(&mut self, data: &MeshData, desc: MaterialDesc) -> Mesh {
let material = self.ctx.create_material(desc);
let mesh = self.ctx.create_mesh(data, material);
self.renderer
.create_material(&self.device, &GpuMaterialDesc::new(&desc), &self.textures);
self.renderer
.create_mesh(&self.device, data, &[(0..data.indices.len() as u32, material)], true);
mesh
}
fn draw(&mut self) -> Vec<u8> {
let ctx = &mut self.ctx;
let mut frame = Frame3D::default();
frame.lod = ctx.lod;
frame.collect(
&mut ctx.world,
&ctx.assets3d,
&SkinFrame::default(),
&ctx.camera3d,
&ctx.lighting,
);
let scene = Scene3D {
frame: &frame,
lighting: &ctx.lighting,
sky: &ctx.sky,
light: SkyLight {
sun: Vec3::splat(ctx.lighting.sun_intensity),
sky: Vec3::ZERO,
ground: Vec3::ZERO,
},
camera: ctx.camera3d.position,
post: &ctx.post,
time: (0.0, 1.0 / 60.0),
occlusion: false,
};
self.renderer.prepare(
&self.device,
&self.queue,
&Prepare3D {
scene: &scene,
lut: None,
size: (SIZE, SIZE),
},
);
let buffers = self
.renderer
.draw(&self.device, &self.target, wgpu::Color::BLACK, &self.textures, None);
self.queue.submit(buffers);
let readback = self.device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: u64::from(SIZE * SIZE * 4),
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = self.device.create_command_encoder(&Default::default());
encoder.copy_texture_to_buffer(
self.output.as_image_copy(),
wgpu::TexelCopyBufferInfo {
buffer: &readback,
layout: wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(SIZE * 4),
rows_per_image: None,
},
},
self.output.size(),
);
self.queue.submit([encoder.finish()]);
readback.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
self.device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
readback.get_mapped_range(..).unwrap().to_vec()
}
}
#[test]
fn shadows_cut_the_fogs_sun_glow_into_shafts() {
let Some(mut rig) = Rig::new() else { return };
let black = rig.mesh(&MeshData::cube(1.0), MaterialDesc::color(Color::BLACK));
rig.ctx.world.spawn((
Transform3D {
position: vec3(-20.0, 10.0, -20.0),
scale: vec3(40.0, 1.0, 60.0),
..Default::default()
},
Model::new(black),
));
rig.ctx.world.spawn((
Transform3D {
position: vec3(0.0, 0.0, -30.0),
scale: vec3(100.0, 40.0, 1.0),
..Default::default()
},
Model::new(black),
));
rig.ctx.lighting.shadows = true;
rig.ctx.lighting.sun_direction = vec3(0.1, -1.0, 0.05);
rig.ctx.camera3d.position = vec3(0.0, 2.0, 0.0);
rig.ctx.camera3d.look_at(vec3(0.0, 2.0, -1.0));
rig.ctx.sky.fog_density = 0.05;
rig.ctx.sky.fog_height = 50.0;
rig.ctx.sky.fog_color = Color::BLACK;
rig.ctx.sky.fog_sun_glow = 1.0;
rig.ctx.sky.fog_sun_focus = 0.0;
let (left, right) = ((SIZE / 4, SIZE / 2), (SIZE * 3 / 4, SIZE / 2));
let red = |pixels: &[u8], (x, y): (u32, u32)| i32::from(pixels[((y * SIZE + x) * 4) as usize]);
let pixels = rig.draw();
let (shade, sun) = (red(&pixels, left), red(&pixels, right));
assert!(
shade > 100 && (shade - sun).abs() < 20,
"without shafts, all glows: {shade} {sun}"
);
rig.ctx.sky.light_shafts = 1.0;
let pixels = rig.draw();
let (shade, sun) = (red(&pixels, left), red(&pixels, right));
assert!(shade < 30, "the fog under the roof is dark: {shade}");
assert!(sun > 100, "the fog in the sun glows: {sun}");
}