use wasm_bindgen::prelude::*;
use crate::raytrace::{CpuBackend, DenoiseParams, RaytraceRenderer};
use crate::wasm::{WebCamera, WebRenderer, WebScene};
#[wasm_bindgen]
pub struct WebPathTracer {
inner: RaytraceRenderer,
}
#[wasm_bindgen]
impl WebPathTracer {
#[wasm_bindgen(constructor)]
pub fn new(width: u32, height: u32) -> WebPathTracer {
Self {
inner: RaytraceRenderer::new(width.max(1), height.max(1)),
}
}
pub async fn new_gpu(width: u32, height: u32) -> Result<WebPathTracer, JsValue> {
let backend = crate::raytrace::gpu::GpuBackend::headless_browser()
.await
.map_err(|e| JsValue::from_str(&e.to_string()))?;
Ok(Self {
inner: RaytraceRenderer::with_backend(width.max(1), height.max(1), Box::new(backend)),
})
}
pub fn new_gpu_from_renderer(renderer: &WebRenderer, width: u32, height: u32) -> WebPathTracer {
let (device, queue) = renderer.gpu_device_queue();
let backend = crate::raytrace::gpu::GpuBackend::with_device(device, queue);
Self {
inner: RaytraceRenderer::with_backend(width.max(1), height.max(1), Box::new(backend)),
}
}
#[wasm_bindgen(js_name = setSize)]
pub fn set_size(&mut self, width: u32, height: u32) -> Vec<u32> {
let (w, h) = self.inner.set_size(width.max(1), height.max(1));
vec![w, h]
}
#[wasm_bindgen(js_name = maxFilmSide)]
pub fn max_film_side(&self) -> u32 {
self.inner.max_film_side().unwrap_or(0)
}
#[wasm_bindgen(js_name = maxAccumPixels)]
pub fn max_accum_pixels(&self) -> f64 {
self.inner.max_film_pixels().unwrap_or(0) as f64
}
#[wasm_bindgen(js_name = atlasSide)]
pub fn atlas_side(&self) -> u32 {
self.inner.gpu_caps().map(|c| c.atlas_side).unwrap_or(0)
}
#[wasm_bindgen(js_name = setSamples)]
pub fn set_samples(&mut self, spp: u32) {
let s = self.inner.settings().clone().with_samples(spp.max(1));
self.inner.set_settings(s);
}
#[wasm_bindgen(js_name = setBounces)]
pub fn set_bounces(&mut self, n: u32) {
let s = self.inner.settings().clone().with_bounces(n.max(1));
self.inner.set_settings(s);
}
#[wasm_bindgen(js_name = setSeed)]
pub fn set_seed(&mut self, seed: u64) {
let s = self.inner.settings().clone().with_seed(seed);
self.inner.set_settings(s);
}
#[wasm_bindgen(js_name = setDenoise)]
pub fn set_denoise(&mut self, on: bool) {
self.inner.set_denoise(on);
}
#[wasm_bindgen(js_name = setDenoiseParams)]
pub fn set_denoise_params(
&mut self,
iterations: u32,
sigma_color: f32,
sigma_normal: f32,
sigma_depth: f32,
sigma_albedo: f32,
min_samples: u32,
) {
self.inner.set_denoise_params(DenoiseParams {
iterations,
sigma_color,
sigma_normal,
sigma_depth,
sigma_albedo,
min_samples,
});
}
#[wasm_bindgen(js_name = setExposure)]
pub fn set_exposure(&mut self, exposure: f32) {
self.inner.set_exposure(exposure);
}
#[wasm_bindgen(js_name = setAov)]
pub fn set_aov(&mut self, name: &str) -> Result<(), JsValue> {
let aov = match name.trim().to_ascii_lowercase().as_str() {
"beauty" | "colour" | "color" => crate::raytrace::Aov::Beauty,
"albedo" => crate::raytrace::Aov::Albedo,
"normal" => crate::raytrace::Aov::Normal,
"depth" => crate::raytrace::Aov::Depth,
other => {
return Err(JsValue::from_str(&format!(
"unknown aov '{other}' (beauty|albedo|normal|depth)"
)))
}
};
self.inner.set_aov(aov);
Ok(())
}
#[wasm_bindgen(js_name = resolveRgbaAov)]
pub fn resolve_rgba_aov(&mut self, name: &str) -> Result<Vec<u8>, JsValue> {
let aov = match name.trim().to_ascii_lowercase().as_str() {
"beauty" | "colour" | "color" => crate::raytrace::Aov::Beauty,
"albedo" => crate::raytrace::Aov::Albedo,
"normal" => crate::raytrace::Aov::Normal,
"depth" => crate::raytrace::Aov::Depth,
other => {
return Err(JsValue::from_str(&format!(
"unknown aov '{other}' (beauty|albedo|normal|depth)"
)))
}
};
Ok(self.inner.resolve_rgba_aov(aov))
}
#[wasm_bindgen(js_name = resolveRgbaAsync)]
pub async fn resolve_rgba_async(&mut self, denoise: bool) -> Vec<u8> {
self.inner.resolve_rgba_denoised_async(denoise).await
}
#[wasm_bindgen(js_name = resolveRgbaSamples)]
pub fn resolve_rgba_samples(&mut self) -> Vec<u8> {
self.inner.resolve_rgba_samples()
}
#[wasm_bindgen(js_name = sampleRange)]
pub fn sample_range(&self) -> Vec<u32> {
let (lo, hi) = self.inner.sample_range();
vec![lo, hi]
}
#[wasm_bindgen(js_name = reportSummary)]
pub fn report_summary(&self) -> String {
self.inner.report().map(|r| r.summary()).unwrap_or_default()
}
#[wasm_bindgen(js_name = resolveRgbaErrorOverlay)]
pub fn resolve_rgba_error_overlay(&mut self, strength: f32) -> Vec<u8> {
self.inner.resolve_rgba_error_overlay(strength)
}
#[wasm_bindgen(js_name = setAdaptive)]
pub fn set_adaptive(&mut self, threshold: f32) {
self.inner.set_adaptive(threshold);
}
#[wasm_bindgen(js_name = setSampleRedistribution)]
pub fn set_sample_redistribution(&mut self, on: bool) {
self.inner.set_sample_redistribution(on);
}
#[wasm_bindgen(js_name = setAdaptiveMinSamples)]
pub fn set_adaptive_min_samples(&mut self, n: u32) {
self.inner.set_adaptive_min_samples(n);
}
#[wasm_bindgen(js_name = setSampleBudget)]
pub fn set_sample_budget(&mut self, spp: u32) {
self.inner.set_sample_budget(spp);
}
#[wasm_bindgen(js_name = setClampIndirect)]
pub fn set_clamp_indirect(&mut self, clamp: f32) {
self.inner.set_clamp_indirect(clamp);
}
#[wasm_bindgen(js_name = setCausticGlassShadows)]
pub fn set_caustic_glass_shadows(&mut self, on: bool) {
self.inner.set_caustic_glass_shadows(on);
}
#[wasm_bindgen(js_name = setSamplesPerDispatch)]
pub fn set_samples_per_dispatch(&mut self, n: u32) -> bool {
self.inner.set_samples_per_dispatch(n)
}
#[wasm_bindgen(js_name = setMotionBlur)]
pub fn set_motion_blur(&mut self, shutter: f32) {
let s = self.inner.settings().clone().with_motion_blur(shutter);
self.inner.set_settings(s);
}
#[wasm_bindgen(js_name = encodeExr)]
pub fn encode_exr(&mut self) -> Result<Vec<u8>, JsValue> {
self.inner.encode_exr().map_err(|e| JsValue::from_str(&e))
}
#[wasm_bindgen(js_name = recommendedTileSize)]
pub fn recommended_tile_size(&self) -> u32 {
self.inner.recommended_tile_size()
}
pub fn prepare(&mut self, scene: &mut WebScene, camera: &WebCamera) {
camera.prepare_path_tracer(scene, &mut self.inner);
}
#[wasm_bindgen(js_name = prepareIfChanged)]
pub fn prepare_if_changed(&mut self, scene: &mut WebScene, camera: &WebCamera) -> bool {
camera.prepare_path_tracer_if_changed(scene, &mut self.inner)
}
pub fn accumulate(&mut self, samples: u32) -> Result<(), JsValue> {
self.inner
.accumulate(samples)
.map_err(|e| JsValue::from_str(&e.to_string()))
}
#[wasm_bindgen(js_name = accumulateRegion)]
pub fn accumulate_region(
&mut self,
x: u32,
y: u32,
width: u32,
height: u32,
samples: u32,
) -> Result<(), JsValue> {
self.inner
.accumulate_region(x, y, width, height, samples)
.map_err(|e| JsValue::from_str(&e.to_string()))
}
#[wasm_bindgen(js_name = accumulateTiles)]
pub fn accumulate_tiles(&mut self, tile_size: u32, samples: u32) -> Result<(), JsValue> {
self.inner
.accumulate_tiles(tile_size, samples)
.map_err(|e| JsValue::from_str(&e.to_string()))
}
#[wasm_bindgen(js_name = accumulateUnconvergedTiles)]
pub fn accumulate_unconverged_tiles(
&mut self,
tile_size: u32,
samples: u32,
) -> Result<(), JsValue> {
self.inner
.accumulate_unconverged_tiles(tile_size, samples)
.map_err(|e| JsValue::from_str(&e.to_string()))
}
#[wasm_bindgen(js_name = needsMoreSamples)]
pub fn needs_more_samples(&self) -> bool {
self.inner.needs_more_samples()
}
#[wasm_bindgen(js_name = accumulateUnconvergedTilesLimited)]
pub fn accumulate_unconverged_tiles_limited(
&mut self,
tile_size: u32,
samples: u32,
max_tiles: u32,
) -> Result<(), JsValue> {
self.inner
.accumulate_unconverged_tiles_limited(tile_size, samples, max_tiles)
.map_err(|e| JsValue::from_str(&e.to_string()))
}
#[wasm_bindgen(js_name = accumulateUnconvergedTilesBudgeted)]
pub fn accumulate_unconverged_tiles_budgeted(
&mut self,
tile_size: u32,
samples: u32,
max_tiles: u32,
max_ms: u32,
) -> Result<u32, JsValue> {
self.inner
.accumulate_unconverged_tiles_budgeted(tile_size, samples, max_tiles, max_ms)
.map_err(|e| JsValue::from_str(&e.to_string()))
}
#[wasm_bindgen(js_name = lastTileMs)]
pub fn last_tile_ms(&self) -> f32 {
self.inner.last_tile_ms()
}
pub fn width(&self) -> u32 {
self.inner.size().0
}
pub fn height(&self) -> u32 {
self.inner.size().1
}
#[wasm_bindgen(js_name = isConverged)]
pub fn is_converged(&self) -> bool {
self.inner.is_converged()
}
#[wasm_bindgen(js_name = filmCheckpointBytes)]
pub fn film_checkpoint_bytes(&mut self) -> Vec<u8> {
self.inner.film_checkpoint().to_bytes()
}
#[wasm_bindgen(js_name = restoreFilmBytes)]
pub fn restore_film_bytes(&mut self, bytes: &[u8]) -> Result<(), JsValue> {
self.inner
.restore_film_bytes(bytes)
.map_err(|e| JsValue::from_str(&e))
}
#[wasm_bindgen(js_name = unconvergedTileCount)]
pub fn unconverged_tile_count(&self, tile_size: u32) -> u32 {
self.inner.unconverged_tile_count(tile_size)
}
#[wasm_bindgen(js_name = resolveRgba)]
pub fn resolve_rgba(&mut self) -> Vec<u8> {
self.inner.resolve_rgba()
}
#[wasm_bindgen(js_name = resolveRgbaDenoised)]
pub fn resolve_rgba_denoised(&mut self, denoise: bool) -> Vec<u8> {
self.inner.resolve_rgba_denoised(denoise)
}
#[wasm_bindgen(js_name = resolveHdr)]
pub fn resolve_hdr(&mut self) -> Vec<f32> {
self.inner.resolve_hdr()
}
#[wasm_bindgen(js_name = flushGpuFilm)]
pub fn flush_gpu_film(&mut self) -> Result<(), JsValue> {
self.inner
.flush_gpu_film()
.map_err(|e| JsValue::from_str(&e.to_string()))
}
#[wasm_bindgen(js_name = setDeferGpuReadback)]
pub fn set_defer_gpu_readback(&mut self, on: bool) -> bool {
self.inner.set_defer_gpu_readback(on)
}
pub fn samples(&self) -> u32 {
self.inner.film().samples()
}
#[wasm_bindgen(js_name = backendName)]
pub fn backend_name(&self) -> String {
self.inner.backend_name().to_string()
}
#[wasm_bindgen(js_name = convergedFraction)]
pub fn converged_fraction(&self) -> f32 {
self.inner.render_stats().converged_fraction
}
#[wasm_bindgen(js_name = sampleEfficiency)]
pub fn sample_efficiency(&self) -> f32 {
self.inner.sample_efficiency()
}
pub fn reset(&mut self) {
self.inner.reset_film();
}
#[wasm_bindgen(js_name = mergeFilmBytes)]
pub fn merge_film_bytes(&mut self, bytes: &[u8]) -> Result<(), JsValue> {
let cp = crate::raytrace::FilmCheckpoint::from_bytes(bytes)
.map_err(|e| JsValue::from_str(&e))?;
self.inner
.merge_film_checkpoint(&cp)
.map_err(|e| JsValue::from_str(&e))
}
#[wasm_bindgen(js_name = resolveSampleCounts)]
pub fn resolve_sample_counts(&mut self) -> Vec<u32> {
self.inner.resolve_sample_counts()
}
#[wasm_bindgen(js_name = resolveError)]
pub fn resolve_error(&mut self) -> Vec<f32> {
self.inner.resolve_error()
}
}
impl WebPathTracer {
pub fn use_cpu(&mut self) {
let (w, h) = self.inner.size();
let settings = self.inner.settings().clone();
let mut r = RaytraceRenderer::with_backend(w, h, Box::new(CpuBackend::new()));
r.set_settings(settings);
self.inner = r;
}
}
#[wasm_bindgen]
pub struct WebHybridCompositor {
inner: crate::raytrace::HybridCompositor,
}
#[wasm_bindgen]
impl WebHybridCompositor {
#[wasm_bindgen(constructor)]
pub fn new() -> WebHybridCompositor {
WebHybridCompositor {
inner: crate::raytrace::HybridCompositor::default(),
}
}
#[wasm_bindgen(js_name = setBlend)]
pub fn set_blend(&mut self, mix: f32, detail: f32, edge_sigma: f32) {
let p = &mut self.inner.params;
p.mix = mix.clamp(0.0, 1.0);
p.detail = detail.clamp(0.0, 1.0);
p.edge_sigma = edge_sigma.max(0.01);
}
#[wasm_bindgen(js_name = setBloom)]
pub fn set_bloom(&mut self, strength: f32, threshold: f32, knee: f32, levels: u32) {
let p = &mut self.inner.params;
p.bloom_strength = strength.max(0.0);
p.bloom_threshold = threshold.max(0.0);
p.bloom_knee = knee.max(0.0);
p.bloom_levels = levels.clamp(1, 8);
}
pub fn composite(
&mut self,
raster: &[u8],
w: u32,
h: u32,
trace: &[u8],
tw: u32,
th: u32,
) -> Result<Vec<u8>, JsValue> {
self.inner
.composite(raster, w, h, trace, tw, th)
.map_err(|e| JsValue::from_str(&e.to_string()))
}
#[wasm_bindgen(js_name = bloom)]
pub fn bloom(&mut self, rgba: &[u8], w: u32, h: u32) -> Result<Vec<u8>, JsValue> {
self.inner
.bloom_rgba(rgba, w, h)
.map_err(|e| JsValue::from_str(&e.to_string()))
}
}
impl Default for WebHybridCompositor {
fn default() -> Self {
Self::new()
}
}