Compare commits
No commits in common. "453a67a93f4fb8287d0278a01893e6fe8a060801" and "bf62a59a0e30b4548ae876cca3366c37bb731128" have entirely different histories.
453a67a93f
...
bf62a59a0e
63
Cargo.lock
generated
63
Cargo.lock
generated
|
|
@ -100,18 +100,6 @@ dependencies = [
|
|||
"libloading",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "async-channel"
|
||||
version = "2.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "89b47800b0be77592da0afd425cc03468052844aff33b84e33cc696f64e77b6a"
|
||||
dependencies = [
|
||||
"concurrent-queue",
|
||||
"event-listener-strategy",
|
||||
"futures-core",
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "atomic-waker"
|
||||
version = "1.1.2"
|
||||
|
|
@ -413,27 +401,6 @@ dependencies = [
|
|||
"windows-sys 0.59.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "event-listener"
|
||||
version = "5.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba"
|
||||
dependencies = [
|
||||
"concurrent-queue",
|
||||
"parking",
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "event-listener-strategy"
|
||||
version = "0.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3c3e4e0dd3673c1139bf041f3008816d9cf2946bbfac2945c09e523b8d7b05b2"
|
||||
dependencies = [
|
||||
"event-listener",
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fdeflate"
|
||||
version = "0.3.7"
|
||||
|
|
@ -486,12 +453,6 @@ version = "0.3.1"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
|
||||
|
||||
[[package]]
|
||||
name = "futures-core"
|
||||
version = "0.3.31"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
|
||||
|
||||
[[package]]
|
||||
name = "gethostname"
|
||||
version = "0.4.3"
|
||||
|
|
@ -634,23 +595,12 @@ checksum = "cd6f44aed642f18953a158afeb30206f4d50da59fbc66ecb53c66488de73563b"
|
|||
dependencies = [
|
||||
"bytemuck",
|
||||
"byteorder-lite",
|
||||
"image-webp",
|
||||
"num-traits",
|
||||
"png",
|
||||
"zune-core",
|
||||
"zune-jpeg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "image-webp"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e031e8e3d94711a9ccb5d6ea357439ef3dcbed361798bd4071dc4d9793fbe22f"
|
||||
dependencies = [
|
||||
"byteorder-lite",
|
||||
"quick-error",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "indexmap"
|
||||
version = "2.7.0"
|
||||
|
|
@ -1156,12 +1106,6 @@ dependencies = [
|
|||
"ttf-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "parking"
|
||||
version = "2.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
|
||||
|
||||
[[package]]
|
||||
name = "parking_lot"
|
||||
version = "0.12.3"
|
||||
|
|
@ -1302,12 +1246,6 @@ version = "1.0.16"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "afbdc74edc00b6f6a218ca6a5364d6226a259d4b8ea1af4a0ea063f27e179f4d"
|
||||
|
||||
[[package]]
|
||||
name = "quick-error"
|
||||
version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
|
||||
|
||||
[[package]]
|
||||
name = "quick-xml"
|
||||
version = "0.36.2"
|
||||
|
|
@ -1391,7 +1329,6 @@ checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
|
|||
name = "raytracing3"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"async-channel",
|
||||
"bytemuck",
|
||||
"glam",
|
||||
"image",
|
||||
|
|
|
|||
12
Cargo.toml
12
Cargo.toml
|
|
@ -4,20 +4,10 @@ version = "0.1.0"
|
|||
edition = "2021"
|
||||
default-run = "minitracer"
|
||||
|
||||
[profile.dev]
|
||||
panic = 'abort'
|
||||
|
||||
[profile.dev.package."*"]
|
||||
opt-level = 3
|
||||
|
||||
[profile.test.package."*"]
|
||||
opt-level = 3
|
||||
|
||||
[dependencies]
|
||||
async-channel = "2.3.1"
|
||||
bytemuck = { version = "1.21.0", features = ["derive"] }
|
||||
glam = { version = "0.29.2", features = ["bytemuck"] }
|
||||
image = { version = "0.25.5", default-features = false, features = ["png", "jpeg", "webp"] }
|
||||
image = { version = "0.25.5", default-features = false, features = ["png", "jpeg"] }
|
||||
pollster = "0.4.0"
|
||||
rand = "0.8.5"
|
||||
rand_distr = { version = "0.4.3", features = ["std_math"] }
|
||||
|
|
|
|||
|
|
@ -121,7 +121,7 @@ fn main() {
|
|||
let img =
|
||||
image::RgbaImage::from_raw(extent, extent, buf.slice(..).get_mapped_range().to_vec()).unwrap();
|
||||
let img: image::RgbImage = img.convert();
|
||||
img.save(format!("textures/env{face}.webp")).unwrap();
|
||||
img.save(format!("textures/env{face}.jpeg")).unwrap();
|
||||
});
|
||||
}
|
||||
})
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
use glam::{vec3, Vec3};
|
||||
use rand_distr::{Bernoulli, Distribution, Uniform};
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct SphereParams {
|
||||
pub radius: f32,
|
||||
pub alpha: f32,
|
||||
|
|
@ -23,7 +22,7 @@ pub fn distr<R: rand::Rng>() -> impl Fn(&mut R) -> SphereParams {
|
|||
move |rgen| SphereParams {
|
||||
origin: pos.sample3(rgen),
|
||||
radius: 2.0f32.powf(rad.sample(rgen)),
|
||||
alpha: if emit.sample(rgen) { 100.0 } else { 0.0 },
|
||||
alpha: if emit.sample(rgen) { 10.0 } else { 0.0 },
|
||||
glossiness: gloss.sample(rgen),
|
||||
amplitudes: ampl.sample3(rgen),
|
||||
frequencies: freq.sample3(rgen),
|
||||
|
|
@ -1,14 +1,45 @@
|
|||
use std::error::Error;
|
||||
|
||||
use glam::uvec2;
|
||||
use raytracing3::present::{self, Presenter};
|
||||
use raytracing3::scene::{load_envmap, Renderer, SceneParams};
|
||||
use glam::{mat3, uvec2, vec3, Vec3};
|
||||
use image::ImageReader;
|
||||
use present::Presenter;
|
||||
use trace::{Tracer, TracerData, TracerEnv};
|
||||
use winit::{
|
||||
event::{Event, WindowEvent},
|
||||
event_loop::EventLoop,
|
||||
window::{Window, WindowAttributes},
|
||||
};
|
||||
|
||||
mod anim;
|
||||
mod present;
|
||||
mod trace;
|
||||
|
||||
pub use trace::Sphere;
|
||||
|
||||
struct CamLoc {
|
||||
eye: Vec3,
|
||||
forward: Vec3,
|
||||
right: Vec3,
|
||||
}
|
||||
|
||||
fn make_viewport(w: u32, h: u32) -> trace::Viewport {
|
||||
let size = uvec2(w, h).as_vec2();
|
||||
let size = size.normalize();
|
||||
trace::Viewport {
|
||||
corner: vec3(size.x, size.y, 1.),
|
||||
}
|
||||
}
|
||||
|
||||
fn convert_location(cam: CamLoc) -> trace::CameraLocation {
|
||||
let fwd = cam.forward.normalize();
|
||||
let up = cam.right.cross(fwd).normalize();
|
||||
let right = up.cross(fwd).normalize();
|
||||
trace::CameraLocation {
|
||||
eye: cam.eye,
|
||||
view: mat3(right, up, fwd),
|
||||
}
|
||||
}
|
||||
|
||||
const N_SPHERES: u32 = 100;
|
||||
const RAYS_PER_PIXEL: u32 = 4;
|
||||
|
||||
|
|
@ -26,8 +57,27 @@ fn main() {
|
|||
|
||||
let output_format = wgpu::TextureFormat::Bgra8UnormSrgb;
|
||||
let hdr_format = wgpu::TextureFormat::Rgba16Float;
|
||||
let scene = SceneParams::new(N_SPHERES);
|
||||
let renderer = Renderer::new(&device, envmap);
|
||||
let tracer = Tracer::new(&device, hdr_format);
|
||||
let mut rng = rand_pcg::Pcg32::new(42, 0);
|
||||
let sphere_params: Vec<_> = {
|
||||
let distr = anim::distr();
|
||||
(0..N_SPHERES).map(|_| distr(&mut rng)).collect()
|
||||
};
|
||||
let camera_params = {
|
||||
let mut p = anim::distr()(&mut rng);
|
||||
p.amplitudes *= 2.0;
|
||||
p.frequencies *= 0.1;
|
||||
p
|
||||
};
|
||||
let target_params = {
|
||||
let mut p = anim::distr()(&mut rng);
|
||||
p.origin = Vec3::splat(0.0);
|
||||
p.amplitudes *= 0.5;
|
||||
p.frequencies *= 0.1;
|
||||
p
|
||||
};
|
||||
let tracer_env = TracerEnv::new(&device, &tracer, &envmap);
|
||||
|
||||
let presenter = Presenter::new(&device, output_format);
|
||||
|
||||
let mut frame = 0;
|
||||
|
|
@ -76,29 +126,76 @@ fn main() {
|
|||
let hdr = hdr.create_view(&wgpu::TextureViewDescriptor::default());
|
||||
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
|
||||
{
|
||||
let mut render_pass = renderer.prepare(&mut encoder, &hdr);
|
||||
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: None,
|
||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||
view: &hdr,
|
||||
resolve_target: None,
|
||||
ops: wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
|
||||
store: wgpu::StoreOp::Store,
|
||||
},
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
occlusion_query_set: None,
|
||||
timestamp_writes: None,
|
||||
});
|
||||
for _ in 0..RAYS_PER_PIXEL {
|
||||
frame += 1;
|
||||
let time = frame as f32 / (60. * RAYS_PER_PIXEL as f32);
|
||||
renderer.render_frame(
|
||||
&device,
|
||||
let target = sphere_params[0].to_sphere(time - 0.2).center;
|
||||
let eye = camera_params.to_sphere(time).center;
|
||||
let right = camera_params.deriv(time);
|
||||
let forward = target - eye;
|
||||
let viewport = make_viewport(size.width, size.height);
|
||||
let location = convert_location(CamLoc { eye, forward, right });
|
||||
let spheres: Vec<_> = sphere_params.iter().map(|p| p.to_sphere(time)).collect();
|
||||
let data = TracerData::new(&device, &tracer, &spheres);
|
||||
tracer.render(
|
||||
&mut render_pass,
|
||||
uvec2(size.width, size.height),
|
||||
&scene,
|
||||
time,
|
||||
frame,
|
||||
&data,
|
||||
&tracer_env,
|
||||
trace::Params {
|
||||
max_reflections: 3,
|
||||
min_strength: 0.1,
|
||||
sphere_count: N_SPHERES,
|
||||
seed: frame,
|
||||
},
|
||||
viewport,
|
||||
trace::Aperture {
|
||||
radius: 0.001,
|
||||
focal_distance: forward.length(),
|
||||
glare_strength: 0.1,
|
||||
glare_radius: 0.1,
|
||||
},
|
||||
location,
|
||||
);
|
||||
}
|
||||
}
|
||||
presenter.render(
|
||||
&device,
|
||||
&mut encoder,
|
||||
&hdr,
|
||||
&view,
|
||||
present::Params {
|
||||
divisor: RAYS_PER_PIXEL as f32,
|
||||
},
|
||||
);
|
||||
{
|
||||
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: None,
|
||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||
view: &view,
|
||||
resolve_target: None,
|
||||
ops: wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
|
||||
store: wgpu::StoreOp::Store,
|
||||
},
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
occlusion_query_set: None,
|
||||
timestamp_writes: None,
|
||||
});
|
||||
presenter.render(
|
||||
&device,
|
||||
&mut render_pass,
|
||||
&hdr,
|
||||
present::Params {
|
||||
divisor: RAYS_PER_PIXEL as f32,
|
||||
},
|
||||
);
|
||||
}
|
||||
queue.submit(std::iter::once(encoder.finish()));
|
||||
output.present();
|
||||
}
|
||||
|
|
@ -140,3 +237,75 @@ async fn init_gpu(wnd: &Window) -> Result<(wgpu::Device, wgpu::Queue, wgpu::Surf
|
|||
.unwrap();
|
||||
Ok((device, queue, surface))
|
||||
}
|
||||
|
||||
fn load_envmap(device: &wgpu::Device, queue: &wgpu::Queue) -> wgpu::TextureView {
|
||||
let imgs = std::thread::scope(|s| {
|
||||
[0, 1, 2, 3, 4, 5]
|
||||
.map(|face| {
|
||||
s.spawn(move || {
|
||||
let img = ImageReader::open(format!("textures/env{face}.jpeg"))
|
||||
.unwrap()
|
||||
.with_guessed_format()
|
||||
.unwrap()
|
||||
.decode()
|
||||
.unwrap();
|
||||
img.to_rgba8()
|
||||
})
|
||||
})
|
||||
.map(|t| t.join().unwrap())
|
||||
});
|
||||
let size = imgs[0].width();
|
||||
for img in &imgs {
|
||||
assert!(img.width() == size);
|
||||
assert!(img.height() == size);
|
||||
}
|
||||
let texture = device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: None,
|
||||
size: wgpu::Extent3d {
|
||||
width: size,
|
||||
height: size,
|
||||
depth_or_array_layers: 6,
|
||||
},
|
||||
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: &[],
|
||||
});
|
||||
for (face, img) in imgs.iter().enumerate() {
|
||||
queue.write_texture(
|
||||
wgpu::ImageCopyTexture {
|
||||
texture: &texture,
|
||||
mip_level: 0,
|
||||
origin: wgpu::Origin3d {
|
||||
x: 0,
|
||||
y: 0,
|
||||
z: face as u32,
|
||||
},
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
},
|
||||
img.as_raw(),
|
||||
wgpu::ImageDataLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: Some(4 * size),
|
||||
rows_per_image: Some(size),
|
||||
},
|
||||
wgpu::Extent3d {
|
||||
width: size,
|
||||
height: size,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
);
|
||||
}
|
||||
texture.create_view(&wgpu::TextureViewDescriptor {
|
||||
label: None,
|
||||
format: None,
|
||||
dimension: Some(wgpu::TextureViewDimension::Cube),
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
base_mip_level: 0,
|
||||
mip_level_count: None,
|
||||
base_array_layer: 0,
|
||||
array_layer_count: None,
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ impl Presenter {
|
|||
}
|
||||
}
|
||||
|
||||
fn render_internal(
|
||||
pub fn render(
|
||||
&self,
|
||||
device: &wgpu::Device,
|
||||
pass: &mut wgpu::RenderPass,
|
||||
|
|
@ -121,29 +121,4 @@ impl Presenter {
|
|||
pass.set_bind_group(0, &bindings, &[]);
|
||||
pass.draw(0..4, 0..1);
|
||||
}
|
||||
|
||||
pub fn render(
|
||||
&self,
|
||||
device: &wgpu::Device,
|
||||
encoder: &mut wgpu::CommandEncoder,
|
||||
source: &wgpu::TextureView,
|
||||
target: &wgpu::TextureView,
|
||||
params: Params,
|
||||
) {
|
||||
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: None,
|
||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||
view: target,
|
||||
resolve_target: None,
|
||||
ops: wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
|
||||
store: wgpu::StoreOp::Store,
|
||||
},
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
occlusion_query_set: None,
|
||||
timestamp_writes: None,
|
||||
});
|
||||
self.render_internal(device, &mut render_pass, source, params);
|
||||
}
|
||||
}
|
||||
|
|
@ -233,27 +233,6 @@ impl Tracer {
|
|||
Self { view_buf, pipeline }
|
||||
}
|
||||
|
||||
pub fn prepare<'encoder>(
|
||||
&self,
|
||||
encoder: &'encoder mut wgpu::CommandEncoder,
|
||||
target: &wgpu::TextureView,
|
||||
) -> wgpu::RenderPass<'encoder> {
|
||||
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: None,
|
||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||
view: &target,
|
||||
resolve_target: None,
|
||||
ops: wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
|
||||
store: wgpu::StoreOp::Store,
|
||||
},
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
occlusion_query_set: None,
|
||||
timestamp_writes: None,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn render(
|
||||
&self,
|
||||
pass: &mut wgpu::RenderPass,
|
||||
172
src/bin/rec.rs
172
src/bin/rec.rs
|
|
@ -1,172 +0,0 @@
|
|||
use std::env::args;
|
||||
use std::error::Error;
|
||||
use std::fs;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
|
||||
use glam::{uvec2, UVec2};
|
||||
use image::buffer::ConvertBuffer;
|
||||
use raytracing3::present::{self, Presenter};
|
||||
use raytracing3::scene::{load_envmap, Renderer, SceneParams};
|
||||
|
||||
const SIZE: UVec2 = uvec2(1920, 1080);
|
||||
const FRAME_RATE: u32 = 60;
|
||||
const DURATION_SECONDS: u32 = 120;
|
||||
const N_FRAMES: u32 = DURATION_SECONDS * FRAME_RATE;
|
||||
const N_SPHERES: u32 = 100;
|
||||
const RAYS_PER_PIXEL: u32 = 1024;
|
||||
|
||||
fn main() {
|
||||
let args: Vec<_> = args().collect();
|
||||
let [_, path] = args.as_slice() else {
|
||||
panic!("invalid arguments");
|
||||
};
|
||||
let path: PathBuf = path.into();
|
||||
fs::create_dir(&path).expect("failed to create the output directory");
|
||||
|
||||
std::thread::scope(|s| {
|
||||
let (img_sender, img_receiver) = async_channel::bounded::<(u32, Arc<wgpu::Buffer>)>(50);
|
||||
for _ in 0..16 {
|
||||
let img_receiver = img_receiver.clone();
|
||||
let path = &path;
|
||||
s.spawn(move || {
|
||||
while let Ok((frame, buffer)) = img_receiver.recv_blocking() {
|
||||
let img = image::RgbaImage::from_raw(SIZE.x, SIZE.y, buffer.slice(..).get_mapped_range().to_vec())
|
||||
.expect("read failure!");
|
||||
let img: image::RgbImage = img.convert();
|
||||
img.save(path.join(&format!("frame{frame:06}.webp")))
|
||||
.expect("save failure!");
|
||||
}
|
||||
});
|
||||
}
|
||||
do_work(img_sender);
|
||||
});
|
||||
}
|
||||
|
||||
fn do_work(img_sender: async_channel::Sender<(u32, Arc<wgpu::Buffer>)>) {
|
||||
let img_sender = Arc::new(img_sender);
|
||||
|
||||
let (device, queue) = pollster::block_on(init_gpu()).unwrap();
|
||||
let envmap = load_envmap(&device, &queue);
|
||||
queue.submit([]);
|
||||
|
||||
let texsize = wgpu::Extent3d {
|
||||
width: SIZE.x,
|
||||
height: SIZE.y,
|
||||
depth_or_array_layers: 1,
|
||||
};
|
||||
|
||||
let output_format = wgpu::TextureFormat::Rgba8UnormSrgb;
|
||||
let hdr_format = wgpu::TextureFormat::Rgba16Float;
|
||||
|
||||
let scene = SceneParams::new(N_SPHERES);
|
||||
let renderer = Renderer::new(&device, envmap);
|
||||
let presenter = Presenter::new(&device, output_format);
|
||||
|
||||
for frame in 0..N_FRAMES {
|
||||
let output = device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: None,
|
||||
size: texsize,
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: wgpu::TextureDimension::D2,
|
||||
format: output_format,
|
||||
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
|
||||
view_formats: &[],
|
||||
});
|
||||
let view = output.create_view(&wgpu::TextureViewDescriptor::default());
|
||||
let hdr = device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: None,
|
||||
size: texsize,
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: wgpu::TextureDimension::D2,
|
||||
format: hdr_format,
|
||||
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
|
||||
view_formats: &[],
|
||||
});
|
||||
let hdr = hdr.create_view(&wgpu::TextureViewDescriptor::default());
|
||||
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
|
||||
{
|
||||
let mut render_pass = renderer.prepare(&mut encoder, &hdr);
|
||||
for subframe in 0..RAYS_PER_PIXEL {
|
||||
let subframe = frame * RAYS_PER_PIXEL + subframe;
|
||||
let time = subframe as f32 / (RAYS_PER_PIXEL * FRAME_RATE) as f32;
|
||||
renderer.render_frame(&device, &mut render_pass, SIZE, &scene, time, subframe);
|
||||
}
|
||||
}
|
||||
presenter.render(
|
||||
&device,
|
||||
&mut encoder,
|
||||
&hdr,
|
||||
&view,
|
||||
present::Params {
|
||||
divisor: RAYS_PER_PIXEL as f32,
|
||||
},
|
||||
);
|
||||
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: None,
|
||||
size: (4 * SIZE.x * SIZE.y) as u64,
|
||||
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
encoder.copy_texture_to_buffer(
|
||||
wgpu::ImageCopyTexture {
|
||||
texture: &output,
|
||||
mip_level: 0,
|
||||
origin: wgpu::Origin3d::ZERO,
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
},
|
||||
wgpu::ImageCopyBuffer {
|
||||
buffer: &buffer,
|
||||
layout: wgpu::ImageDataLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: Some(4 * SIZE.x),
|
||||
rows_per_image: Some(SIZE.y),
|
||||
},
|
||||
},
|
||||
texsize,
|
||||
);
|
||||
queue.submit([encoder.finish()]);
|
||||
let buffer = Arc::new(buffer);
|
||||
let img_sender = Arc::clone(&img_sender);
|
||||
Arc::clone(&buffer)
|
||||
.slice(..)
|
||||
.map_async(wgpu::MapMode::Read, move |res| {
|
||||
res.unwrap();
|
||||
img_sender.send_blocking((frame, buffer)).unwrap();
|
||||
});
|
||||
}
|
||||
device.poll(wgpu::Maintain::Wait);
|
||||
}
|
||||
|
||||
async fn init_gpu() -> Result<(wgpu::Device, wgpu::Queue), Box<dyn Error>> {
|
||||
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
|
||||
backends: wgpu::Backends::PRIMARY,
|
||||
..Default::default()
|
||||
});
|
||||
let adapter = instance
|
||||
.request_adapter(&wgpu::RequestAdapterOptions {
|
||||
power_preference: wgpu::PowerPreference::default(),
|
||||
compatible_surface: None,
|
||||
force_fallback_adapter: false,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let (device, queue) = adapter
|
||||
.request_device(
|
||||
&wgpu::DeviceDescriptor {
|
||||
label: None,
|
||||
required_features: wgpu::Features::PUSH_CONSTANTS,
|
||||
required_limits: wgpu::Limits {
|
||||
max_push_constant_size: 128,
|
||||
..Default::default()
|
||||
},
|
||||
memory_hints: Default::default(),
|
||||
},
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
Ok((device, queue))
|
||||
}
|
||||
|
|
@ -1,6 +1 @@
|
|||
pub mod anim;
|
||||
pub mod perlin;
|
||||
pub mod present;
|
||||
pub mod scene;
|
||||
pub mod trace;
|
||||
pub use trace::Sphere;
|
||||
|
|
|
|||
206
src/scene.rs
206
src/scene.rs
|
|
@ -1,206 +0,0 @@
|
|||
use crate::anim::{self, SphereParams};
|
||||
use crate::trace::{self, Tracer, TracerData, TracerEnv};
|
||||
use glam::{mat3, uvec2, vec3, UVec2, Vec3};
|
||||
use image::ImageReader;
|
||||
use std::f32::consts::PI;
|
||||
|
||||
struct CamLoc {
|
||||
eye: Vec3,
|
||||
forward: Vec3,
|
||||
right: Vec3,
|
||||
}
|
||||
|
||||
fn make_viewport(w: u32, h: u32) -> trace::Viewport {
|
||||
let size = uvec2(w, h).as_vec2();
|
||||
let size = size.normalize();
|
||||
trace::Viewport {
|
||||
corner: vec3(size.x, size.y, 1.),
|
||||
}
|
||||
}
|
||||
|
||||
fn convert_location(cam: CamLoc) -> trace::CameraLocation {
|
||||
let fwd = cam.forward.normalize();
|
||||
let up = cam.right.cross(fwd).normalize();
|
||||
let right = up.cross(fwd).normalize();
|
||||
trace::CameraLocation {
|
||||
eye: cam.eye,
|
||||
view: mat3(right, up, fwd),
|
||||
}
|
||||
}
|
||||
|
||||
const N_SPHERES: u32 = 100;
|
||||
const CAMERA_LAG: f32 = 0.03;
|
||||
|
||||
pub struct Renderer {
|
||||
tracer: Tracer,
|
||||
env: TracerEnv,
|
||||
}
|
||||
|
||||
impl Renderer {
|
||||
pub fn new(device: &wgpu::Device, env: wgpu::TextureView) -> Self {
|
||||
let hdr_format = wgpu::TextureFormat::Rgba16Float;
|
||||
let tracer = Tracer::new(&device, hdr_format);
|
||||
let env = TracerEnv::new(&device, &tracer, &env);
|
||||
Self { tracer, env }
|
||||
}
|
||||
}
|
||||
|
||||
pub struct SceneParams {
|
||||
pub spheres: Vec<SphereParams>,
|
||||
pub camera: SphereParams,
|
||||
pub target: SphereParams,
|
||||
}
|
||||
|
||||
impl SceneParams {
|
||||
pub fn new(n_spheres: u32) -> Self {
|
||||
let mut rng = rand_pcg::Pcg32::new(42, 0);
|
||||
let spheres: Vec<_> = {
|
||||
let distr = anim::distr();
|
||||
(0..n_spheres).map(|_| distr(&mut rng)).collect()
|
||||
};
|
||||
let camera = {
|
||||
let mut p = anim::distr()(&mut rng);
|
||||
p.amplitudes *= 2.0;
|
||||
p.frequencies *= 0.1;
|
||||
p
|
||||
};
|
||||
let target = {
|
||||
let mut p = spheres[0];
|
||||
p.phases -= 2. * PI * CAMERA_LAG * p.frequencies;
|
||||
p
|
||||
};
|
||||
Self {
|
||||
spheres,
|
||||
camera,
|
||||
target,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for SceneParams {
|
||||
fn default() -> Self {
|
||||
Self::new(N_SPHERES)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct RenderPass<'encoder>(wgpu::RenderPass<'encoder>);
|
||||
|
||||
impl Renderer {
|
||||
pub fn prepare<'encoder>(
|
||||
&self,
|
||||
encoder: &'encoder mut wgpu::CommandEncoder,
|
||||
target: &wgpu::TextureView,
|
||||
) -> RenderPass<'encoder> {
|
||||
RenderPass(self.tracer.prepare(encoder, target))
|
||||
}
|
||||
|
||||
pub fn render_frame(
|
||||
&self,
|
||||
device: &wgpu::Device,
|
||||
render_pass: &mut RenderPass,
|
||||
size: UVec2,
|
||||
scene: &SceneParams,
|
||||
time: f32,
|
||||
seed: u32,
|
||||
) {
|
||||
let target = scene.target.to_sphere(time).center;
|
||||
let eye = scene.camera.to_sphere(time).center;
|
||||
let right = scene.camera.deriv(time);
|
||||
let forward = target - eye;
|
||||
let viewport = make_viewport(size.x, size.y);
|
||||
let location = convert_location(CamLoc { eye, forward, right });
|
||||
let spheres: Vec<_> = scene.spheres.iter().map(|p| p.to_sphere(time)).collect();
|
||||
let data = TracerData::new(&device, &self.tracer, &spheres);
|
||||
self.tracer.render(
|
||||
&mut render_pass.0,
|
||||
&data,
|
||||
&self.env,
|
||||
trace::Params {
|
||||
max_reflections: 3,
|
||||
min_strength: 0.1,
|
||||
sphere_count: N_SPHERES,
|
||||
seed,
|
||||
},
|
||||
viewport,
|
||||
trace::Aperture {
|
||||
radius: 0.001,
|
||||
focal_distance: forward.length(),
|
||||
glare_strength: 0.1,
|
||||
glare_radius: 0.1,
|
||||
},
|
||||
location,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn load_envmap(device: &wgpu::Device, queue: &wgpu::Queue) -> wgpu::TextureView {
|
||||
let imgs = std::thread::scope(|s| {
|
||||
[0, 1, 2, 3, 4, 5]
|
||||
.map(|face| {
|
||||
s.spawn(move || {
|
||||
let img = ImageReader::open(format!("textures/env{face}.webp"))
|
||||
.unwrap()
|
||||
.with_guessed_format()
|
||||
.unwrap()
|
||||
.decode()
|
||||
.unwrap();
|
||||
img.to_rgba8()
|
||||
})
|
||||
})
|
||||
.map(|t| t.join().unwrap())
|
||||
});
|
||||
let size = imgs[0].width();
|
||||
for img in &imgs {
|
||||
assert!(img.width() == size);
|
||||
assert!(img.height() == size);
|
||||
}
|
||||
let texture = device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: None,
|
||||
size: wgpu::Extent3d {
|
||||
width: size,
|
||||
height: size,
|
||||
depth_or_array_layers: 6,
|
||||
},
|
||||
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: &[],
|
||||
});
|
||||
for (face, img) in imgs.iter().enumerate() {
|
||||
queue.write_texture(
|
||||
wgpu::ImageCopyTexture {
|
||||
texture: &texture,
|
||||
mip_level: 0,
|
||||
origin: wgpu::Origin3d {
|
||||
x: 0,
|
||||
y: 0,
|
||||
z: face as u32,
|
||||
},
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
},
|
||||
img.as_raw(),
|
||||
wgpu::ImageDataLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: Some(4 * size),
|
||||
rows_per_image: Some(size),
|
||||
},
|
||||
wgpu::Extent3d {
|
||||
width: size,
|
||||
height: size,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
);
|
||||
}
|
||||
texture.create_view(&wgpu::TextureViewDescriptor {
|
||||
label: None,
|
||||
format: None,
|
||||
dimension: Some(wgpu::TextureViewDimension::Cube),
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
base_mip_level: 0,
|
||||
mip_level_count: None,
|
||||
base_array_layer: 0,
|
||||
array_layer_count: None,
|
||||
})
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user