wito/pbrt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: wito:853e980e8347fceff2e6ce7a2e4165bd26cf04aa
Branches Tags
wito:main
wito:allocatorvec
wito:arena
...
compare: wito:7db434535b5fa4a6cbf2478c5b9260808132f8aa
Branches Tags
wito:allocatorvec
wito:arena
wito:main

3 commits
853e980e83 ... 7db434535b

Author SHA1 Message Date
Wito Wiala
7db434535b Very, utterly broken 2026-06-08 16:32:59 +01:00
Wito Wiala
dac5d2c28f Very broken 2026-06-07 18:53:23 +01:00
Wito Wiala
4e1b3619f4 Major overhaul to Texture handling 2026-06-06 18:34:29 +01:00
42 changed files with 887 additions and 757 deletions
Show stats Expand all files Collapse all files

8
shared/src/core/bssrdf.rs
View file

@ -6,8 +6,8 @@ use crate::core::shape::Shape;
use crate::spectra::{SampledSpectrum, N_SPECTRUM_SAMPLES};
use crate::utils::math::{catmull_rom_weights, square};
use crate::utils::sampling::sample_catmull_rom_2d;
use crate::utils::Ptr;
use crate::{gvec_with_capacity, Float, GVec, PI};
use crate::core::{LightIdx, MaterialIdx};
use crate::{gvec_with_capacity, Float, GVec, PI, Ptr};
use enum_dispatch::enum_dispatch;
use num_traits::Float as NumFloat;
@ -78,8 +78,8 @@ impl From<&SubsurfaceInteraction> for SurfaceInteraction {
dndv: Normal3f::zero(),
},
face_index: 0,
area_light: Ptr::null(),
material: Ptr::null(),
area_light: LightIdx::default(),
material: MaterialIdx::default(),
dpdx: Vector3f::zero(),
dpdy: Vector3f::zero(),
dudx: 0.,

34
shared/src/core/handle.rs Normal file
View file

@ -0,0 +1,34 @@
use crate::core::light::Light;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct LightIdx(pub u32);
impl LightIdx {
pub const NONE: Self = LightIdx(u32::MAX);
pub fn is_none(self) -> bool { self.0 == u32::MAX }
}
impl Default for LightIdx {
fn default() -> Self { Self::NONE }
}
impl LightIdx {
#[inline]
pub fn get(self, lights: &[Light]) -> &Light {
&lights[self.0 as usize]
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct MaterialIdx(pub u32);
impl MaterialIdx {
pub const NONE: Self = MaterialIdx(u32::MAX);
pub fn is_none(self) -> bool { self.0 == u32::MAX }
}
impl Default for MaterialIdx {
fn default() -> Self { Self::NONE }
}

48
shared/src/core/image.rs
View file

@ -1,8 +1,8 @@
use crate::core::color::{ColorEncoding, ColorEncodingTrait, LINEAR};
use crate::core::geometry::{Bounds2f, Point2f, Point2fi, Point2i};
use crate::utils::math::{f16_to_f32_software, lerp, square};
use crate::{gvec_with_capacity, Float, GVec};
use anyhow::{Result, bail};
use crate::{gvec_with_capacity, Float, GVec, Ptr};
use anyhow::{bail, Result};
use core::hash;
use core::ops::{Deref, DerefMut};
use num_traits::Float as NumFloat;
@ -23,7 +23,7 @@ impl WrapMode {
"black" => Ok(WrapMode::Black),
"repeat" => Ok(WrapMode::Repeat),
"octahedralsphere" => Ok(WrapMode::OctahedralSphere),
_ => bail!("{:?}: wrap mode unknown", name)
_ => bail!("{:?}: wrap mode unknown", name),
}
}
}
@ -236,6 +236,17 @@ pub struct Image {
pub pixels: Pixels,
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct ImageView {
pub pixels: *const u8,
pub byte_len: usize,
pub resolution: Point2i,
pub n_channels: i32,
pub format: PixelFormat,
pub encoding: ColorEncoding,
}
impl Image {
pub fn new(
format: PixelFormat,
@ -472,3 +483,34 @@ impl Image {
false
}
}
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FilterFunction {
Point,
Bilinear,
Trilinear,
Ewa,
}
impl FilterFunction {
pub fn parse(name: &str) -> Result<FilterFunction> {
match name {
"ewa" | "EWA" => Ok(FilterFunction::Ewa),
"trilinear" => Ok(FilterFunction::Trilinear),
"bilinear" => Ok(FilterFunction::Bilinear),
"point" => Ok(FilterFunction::Point),
_ => bail!("Filter function unknown"),
}
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct ImagePyramid {
pub levels: *const Ptr<Image>,
pub level_count: u32,
pub wrap_mode: WrapMode,
pub filter: FilterFunction,
pub max_aniso: f32,
}

38
shared/src/core/interaction.rs
View file

@ -1,4 +1,3 @@
use crate::Float;
use crate::bxdfs::DiffuseBxDF;
use crate::core::bsdf::BSDF;
use crate::core::bssrdf::BSSRDF;
@ -10,15 +9,16 @@ use crate::core::geometry::{
use crate::core::image::Image;
use crate::core::light::{Light, LightTrait};
use crate::core::material::{
Material, MaterialEvalContext, MaterialTrait, NormalBumpEvalContext, bump_map, normal_map,
bump_map, normal_map, Material, MaterialEvalContext, MaterialTrait, NormalBumpEvalContext,
};
use crate::core::medium::{Medium, MediumInterface, PhaseFunction};
use crate::core::sampler::{Sampler, SamplerTrait};
use crate::core::shape::Shape;
use crate::core::texture::{GPUFloatTexture, UniversalTextureEvaluator};
use crate::core::texture::{FloatTexture, UniversalTextureEvaluator};
use crate::core::{LightIdx, MaterialIdx};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::utils::Ptr;
use crate::utils::math::{clamp, difference_of_products, square};
use crate::{GVec, Ptr, Float};
use enum_dispatch::enum_dispatch;
#[repr(C)]
@ -217,8 +217,8 @@ pub struct ShadingGeom {
#[repr(C)]
#[derive(Debug, Default, Clone, Copy)]
pub struct SurfaceInteraction {
pub area_light: Ptr<Light>,
pub material: Ptr<Material>,
pub area_light: LightIdx,
pub material: MaterialIdx,
pub shape: Ptr<Shape>,
pub common: InteractionBase,
pub shading: ShadingGeom,
@ -239,13 +239,17 @@ unsafe impl Send for SurfaceInteraction {}
unsafe impl Sync for SurfaceInteraction {}
impl SurfaceInteraction {
pub fn le(&self, w: Vector3f, lambda: &SampledWavelengths) -> SampledSpectrum {
if !self.area_light.is_null() {
self.area_light
.l(self.p(), self.n(), self.common.uv, w, lambda)
} else {
SampledSpectrum::new(0.)
pub fn le(
&self,
w: Vector3f,
lambda: &SampledWavelengths,
lights: &GVec<Light>,
) -> SampledSpectrum {
if self.area_light.is_none() {
return SampledSpectrum::new(0.);
}
let light = self.area_light.get(lights);
light.l(self.p(), self.n(), self.common.uv, w, lambda)
}
pub fn compute_differentials(&mut self, r: &Ray, camera: &Camera, samples_per_pixel: i32) {
@ -347,7 +351,7 @@ impl SurfaceInteraction {
pub fn compute_bump_geom(
&mut self,
tex_eval: &UniversalTextureEvaluator,
displacement: Ptr<GPUFloatTexture>,
displacement: Ptr<FloatTexture>,
normal_image: Ptr<Image>,
) {
let ctx = NormalBumpEvalContext::from(&*self);
@ -519,9 +523,9 @@ impl SurfaceInteraction {
dndu,
dndv,
},
material: Ptr::null(),
material: MaterialIdx::default(),
face_index: 0,
area_light: Ptr::null(),
area_light: LightIdx::default(),
dpdx: Vector3f::zero(),
dpdy: Vector3f::zero(),
dudx: 0.0,
@ -591,8 +595,8 @@ impl SurfaceInteraction {
#[cfg(not(target_os = "cuda"))]
pub fn set_intersection_properties(
&mut self,
mtl: Ptr<Material>,
area: Ptr<Light>,
mtl: MaterialIdx,
area: LightIdx,
ray_medium: Ptr<Medium>,
prim_medium_interface: MediumInterface,
) {

6
shared/src/core/material.rs
View file

@ -14,7 +14,7 @@ use crate::core::interaction::{Interaction, InteractionTrait, ShadingGeom, Surfa
use crate::core::scattering::TrowbridgeReitzDistribution;
use crate::core::spectrum::{Spectrum, SpectrumTrait};
use crate::core::texture::{
GPUFloatTexture, GPUSpectrumTexture, TextureEvalContext, TextureEvaluator,
FloatTexture, SpectrumTexture, TextureEvalContext, TextureEvaluator,
};
use crate::materials::*;
use crate::spectra::{SampledSpectrum, SampledWavelengths};
@ -122,7 +122,7 @@ pub fn normal_map(normal_map: &Image, ctx: &NormalBumpEvalContext) -> (Vector3f,
pub fn bump_map<T: TextureEvaluator>(
tex_eval: &T,
displacement: &GPUFloatTexture,
displacement: &FloatTexture,
ctx: &NormalBumpEvalContext,
) -> (Vector3f, Vector3f) {
debug_assert!(tex_eval.can_evaluate(&[Ptr::from(displacement)], &[]));
@ -174,7 +174,7 @@ pub trait MaterialTrait {
fn can_evaluate_textures(&self, tex_eval: &dyn TextureEvaluator) -> bool;
fn get_normal_map(&self) -> Option<&Image>;
fn get_displacement(&self) -> Ptr<GPUFloatTexture>;
fn get_displacement(&self) -> Ptr<FloatTexture>;
fn has_subsurface_scattering(&self) -> bool;
}

3
shared/src/core/mod.rs
View file

@ -7,6 +7,7 @@ pub mod color;
pub mod film;
pub mod filter;
pub mod geometry;
pub mod handle;
pub mod image;
pub mod interaction;
pub mod light;
@ -19,3 +20,5 @@ pub mod scattering;
pub mod shape;
pub mod spectrum;
pub mod texture;
pub use handle::{LightIdx, MaterialIdx};

2
shared/src/core/pbrt.rs
View file

@ -4,7 +4,7 @@ use num_traits::{Float as NumFloat, Num, NumCast, PrimInt};
use crate::core::light::LightTrait;
use crate::core::shape::Shape;
use crate::core::texture::GPUFloatTexture;
use crate::core::texture::FloatTexture;
use crate::lights::*;
use crate::spectra::{DenselySampledSpectrum, RGBColorSpace};
use crate::utils::Ptr;

16
shared/src/core/primitive.rs
View file

@ -4,12 +4,12 @@ use crate::core::interaction::{Interaction, InteractionTrait, SurfaceInteraction
use crate::core::light::Light;
use crate::core::material::Material;
use crate::core::medium::{Medium, MediumInterface};
use crate::core::pbrt::Float;
use crate::core::shape::{Shape, ShapeIntersection, ShapeTrait};
use crate::core::texture::{GPUFloatTexture, TextureEvalContext};
use crate::core::texture::{FloatTexture, TextureEvalContext};
use crate::core::{LightIdx, MaterialIdx};
use crate::utils::hash::hash_float;
use crate::utils::transform::{AnimatedTransform, Transform};
use crate::utils::Ptr;
use crate::{Float, Ptr};
use alloc::boxed::Box;
use alloc::sync::Arc;
@ -26,10 +26,10 @@ pub trait PrimitiveTrait: Send + Sync {
#[derive(Debug, Clone, Copy)]
pub struct GeometricPrimitive {
pub shape: Ptr<Shape>,
pub material: Ptr<Material>,
pub area_light: Ptr<Light>,
pub material: MaterialIdx,
pub area_light: LightIdx,
pub medium_interface: MediumInterface,
pub alpha: Ptr<GPUFloatTexture>,
pub alpha: Ptr<FloatTexture>,
}
unsafe impl Send for GeometricPrimitive {}
@ -91,7 +91,7 @@ impl PrimitiveTrait for GeometricPrimitive {
#[derive(Debug, Copy, Clone)]
pub struct SimplePrimitive {
pub shape: Ptr<Shape>,
pub material: Ptr<Material>,
pub material: MaterialIdx,
}
impl PrimitiveTrait for SimplePrimitive {
@ -103,7 +103,7 @@ impl PrimitiveTrait for SimplePrimitive {
let mut si = self.shape.intersect(r, t_max)?;
si.set_intersection_properties(
self.material,
Ptr::null(),
LightIdx::default(),
MediumInterface::default(),
r.medium,
);

5
shared/src/core/shape.rs
View file

@ -5,6 +5,7 @@ use crate::core::geometry::{
use crate::core::interaction::{
Interaction, InteractionTrait, MediumInteraction, SurfaceInteraction,
};
use crate::core::{MaterialIdx, LightIdx};
use crate::core::light::Light;
use crate::core::material::Material;
use crate::core::medium::{Medium, MediumInterface};
@ -37,8 +38,8 @@ impl ShapeIntersection {
pub fn set_intersection_properties(
&mut self,
mtl: Ptr<Material>,
area: Ptr<Light>,
mtl: MaterialIdx,
area: LightIdx,
prim_medium_interface: MediumInterface,
ray_medium: Ptr<Medium>,
) {

110
shared/src/core/texture.rs
View file

@ -78,7 +78,7 @@ impl UVMapping {
let dsdy = self.su * ctx.dudy;
let dtdx = self.sv * ctx.dvdx;
let dtdy = self.sv * ctx.dvdy;
let st = Point2f::new(self.su * ctx.uv[0] + self.du, self.sv * ctx.uv[1] * self.dv);
let st = Point2f::new(self.su * ctx.uv[0] + self.du, self.sv * ctx.uv[1] + self.dv);
TexCoord2D {
st,
dsdx,
@ -107,7 +107,7 @@ impl SphericalMapping {
let x2y2 = square(pt.x()) + square(pt.y());
let sqrtx2y2 = x2y2.sqrt();
let dsdp = Vector3f::new(-pt.y(), pt.x(), 0.) / (2. * PI * x2y2);
let dtdp = 1. / (PI * (x2y2 * square(pt.z())))
let dtdp = 1. / (PI * (x2y2 + square(pt.z())))
* Vector3f::new(
pt.x() * pt.z() / sqrtx2y2,
pt.y() * pt.z() / sqrtx2y2,
@ -148,7 +148,7 @@ impl CylindricalMapping {
let pt = self.texture_from_render.apply_to_point(ctx.p);
let x2y2 = square(pt.x()) + square(pt.y());
let dsdp = Vector3f::new(-pt.y(), pt.x(), 0.) / (2. * PI * x2y2);
let dtdp = Vector3f::new(1., 0., 0.);
let dtdp = Vector3f::new(0., 0., 1.);
let dpdx = self.texture_from_render.apply_to_vector(ctx.dpdx);
let dpdy = self.texture_from_render.apply_to_vector(ctx.dpdy);
let dsdx = dsdp.dot(dpdx);
@ -341,34 +341,34 @@ impl From<&Interaction> for TextureEvalContext {
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub enum GPUFloatTexture {
pub enum FloatTexture {
Constant(FloatConstantTexture),
DirectionMix(GPUFloatDirectionMixTexture),
Scaled(GPUFloatScaledTexture),
DirectionMix(FloatDirectionMixTexture),
Scaled(FloatScaledTexture),
Bilerp(FloatBilerpTexture),
Checkerboard(FloatCheckerboardTexture),
Dots(FloatDotsTexture),
FBm(FBmTexture),
Windy(WindyTexture),
Wrinkled(WrinkledTexture),
Image(GPUFloatImageTexture),
Mix(GPUFloatMixTexture),
Image(FloatImageTexture),
Mix(FloatMixTexture),
}
impl GPUFloatTexture {
impl FloatTexture {
pub fn evaluate(&self, ctx: &TextureEvalContext) -> Float {
match self {
GPUFloatTexture::Constant(t) => t.evaluate(ctx),
GPUFloatTexture::DirectionMix(t) => t.evaluate(ctx),
GPUFloatTexture::Scaled(t) => t.evaluate(ctx),
GPUFloatTexture::Bilerp(t) => t.evaluate(ctx),
GPUFloatTexture::Checkerboard(t) => t.evaluate(ctx),
GPUFloatTexture::Dots(t) => t.evaluate(ctx),
GPUFloatTexture::FBm(t) => t.evaluate(ctx),
GPUFloatTexture::Windy(t) => t.evaluate(ctx),
GPUFloatTexture::Wrinkled(t) => t.evaluate(ctx),
GPUFloatTexture::Image(t) => t.evaluate(ctx),
GPUFloatTexture::Mix(t) => t.evaluate(ctx),
FloatTexture::Constant(t) => t.evaluate(ctx),
FloatTexture::DirectionMix(t) => t.evaluate(ctx),
FloatTexture::Scaled(t) => t.evaluate(ctx),
FloatTexture::Bilerp(t) => t.evaluate(ctx),
FloatTexture::Checkerboard(t) => t.evaluate(ctx),
FloatTexture::Dots(t) => t.evaluate(ctx),
FloatTexture::FBm(t) => t.evaluate(ctx),
FloatTexture::Windy(t) => t.evaluate(ctx),
FloatTexture::Wrinkled(t) => t.evaluate(ctx),
FloatTexture::Image(t) => t.evaluate(ctx),
FloatTexture::Mix(t) => t.evaluate(ctx),
}
}
}
@ -384,51 +384,51 @@ pub enum SpectrumType {
#[repr(C)]
#[enum_dispatch]
#[derive(Clone, Copy, Debug)]
pub enum GPUSpectrumTexture {
pub enum SpectrumTexture {
Constant(SpectrumConstantTexture),
Bilerp(SpectrumBilerpTexture),
Checkerboard(SpectrumCheckerboardTexture),
Marble(MarbleTexture),
DirectionMix(GPUSpectrumDirectionMixTexture),
DirectionMix(SpectrumDirectionMixTexture),
Dots(SpectrumDotsTexture),
Scaled(GPUSpectrumScaledTexture),
Image(GPUSpectrumImageTexture),
Mix(GPUSpectrumMixTexture),
Scaled(SpectrumScaledTexture),
Image(SpectrumImageTexture),
Mix(SpectrumMixTexture),
}
impl GPUSpectrumTexture {
impl SpectrumTexture {
pub fn evaluate(
&self,
ctx: &TextureEvalContext,
lambda: &SampledWavelengths,
) -> SampledSpectrum {
match self {
GPUSpectrumTexture::Constant(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::Bilerp(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::Checkerboard(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::Marble(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::DirectionMix(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::Dots(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::Scaled(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::Image(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::Mix(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Constant(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Bilerp(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Checkerboard(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Marble(t) => t.evaluate(ctx, lambda),
SpectrumTexture::DirectionMix(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Dots(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Scaled(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Image(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Mix(t) => t.evaluate(ctx, lambda),
}
}
}
pub trait TextureEvaluator: Send + Sync {
fn evaluate_float(&self, tex: &GPUFloatTexture, ctx: &TextureEvalContext) -> Float;
fn evaluate_float(&self, tex: &FloatTexture, ctx: &TextureEvalContext) -> Float;
fn evaluate_spectrum(
&self,
tex: &GPUSpectrumTexture,
tex: &SpectrumTexture,
ctx: &TextureEvalContext,
lambda: &SampledWavelengths,
) -> SampledSpectrum;
fn can_evaluate(
&self,
_ftex: &[Ptr<GPUFloatTexture>],
_stex: &[Ptr<GPUSpectrumTexture>],
_ftex: &[Ptr<FloatTexture>],
_stex: &[Ptr<SpectrumTexture>],
) -> bool;
}
@ -437,13 +437,13 @@ pub trait TextureEvaluator: Send + Sync {
pub struct UniversalTextureEvaluator;
impl TextureEvaluator for UniversalTextureEvaluator {
fn evaluate_float(&self, tex: &GPUFloatTexture, ctx: &TextureEvalContext) -> Float {
fn evaluate_float(&self, tex: &FloatTexture, ctx: &TextureEvalContext) -> Float {
tex.evaluate(ctx)
}
fn evaluate_spectrum(
&self,
tex: &GPUSpectrumTexture,
tex: &SpectrumTexture,
ctx: &TextureEvalContext,
lambda: &SampledWavelengths,
) -> SampledSpectrum {
@ -452,8 +452,8 @@ impl TextureEvaluator for UniversalTextureEvaluator {
fn can_evaluate(
&self,
_float_textures: &[Ptr<GPUFloatTexture>],
_spectrum_textures: &[Ptr<GPUSpectrumTexture>],
_float_textures: &[Ptr<FloatTexture>],
_spectrum_textures: &[Ptr<SpectrumTexture>],
) -> bool {
true
}
@ -464,39 +464,39 @@ impl TextureEvaluator for UniversalTextureEvaluator {
pub struct BasicTextureEvaluator;
impl TextureEvaluator for BasicTextureEvaluator {
fn evaluate_float(&self, tex: &GPUFloatTexture, ctx: &TextureEvalContext) -> Float {
fn evaluate_float(&self, tex: &FloatTexture, ctx: &TextureEvalContext) -> Float {
match tex {
GPUFloatTexture::Constant(t) => t.evaluate(ctx),
GPUFloatTexture::Image(t) => t.evaluate(ctx),
FloatTexture::Constant(t) => t.evaluate(ctx),
FloatTexture::Image(t) => t.evaluate(ctx),
_ => 0.0,
}
}
fn evaluate_spectrum(
&self,
tex: &GPUSpectrumTexture,
tex: &SpectrumTexture,
ctx: &TextureEvalContext,
lambda: &SampledWavelengths,
) -> SampledSpectrum {
match tex {
GPUSpectrumTexture::Constant(t) => t.evaluate(ctx, lambda),
GPUSpectrumTexture::Image(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Constant(t) => t.evaluate(ctx, lambda),
SpectrumTexture::Image(t) => t.evaluate(ctx, lambda),
_ => SampledSpectrum::new(0.0),
}
}
fn can_evaluate(
&self,
ftex: &[Ptr<GPUFloatTexture>],
stex: &[Ptr<GPUSpectrumTexture>],
ftex: &[Ptr<FloatTexture>],
stex: &[Ptr<SpectrumTexture>],
) -> bool {
for t in ftex {
if t.is_null() {
continue;
}
match t.get().unwrap() {
GPUFloatTexture::Constant(_)
| GPUFloatTexture::Image(_) => {}
FloatTexture::Constant(_)
| FloatTexture::Image(_) => {}
_ => return false,
}
}
@ -505,8 +505,8 @@ impl TextureEvaluator for BasicTextureEvaluator {
continue;
}
match t.get().unwrap() {
GPUSpectrumTexture::Constant(_)
| GPUSpectrumTexture::Image(_) => {}
SpectrumTexture::Constant(_)
| SpectrumTexture::Image(_) => {}
_ => return false,
}
}

4
shared/src/lights/diffuse.rs
View file

@ -11,7 +11,7 @@ use crate::core::medium::MediumInterface;
use crate::core::shape::{Shape, ShapeSampleContext, ShapeTrait};
use crate::core::spectrum::{Spectrum, SpectrumTrait};
use crate::core::texture::{
GPUFloatTexture, TextureEvalContext, TextureEvaluator, UniversalTextureEvaluator,
FloatTexture, TextureEvalContext, TextureEvaluator, UniversalTextureEvaluator,
};
use crate::spectra::*;
use crate::utils::hash::hash_float;
@ -24,7 +24,7 @@ use num_traits::Float as NumFloat;
pub struct DiffuseAreaLight {
pub base: LightBase,
pub shape: Ptr<Shape>,
pub alpha: Ptr<GPUFloatTexture>,
pub alpha: Ptr<FloatTexture>,
pub colorspace: Ptr<RGBColorSpace>,
pub lemit: Ptr<DenselySampledSpectrum>,
pub image: Ptr<Image>,

6
shared/src/lights/distant.rs
View file

@ -5,8 +5,8 @@ use crate::core::interaction::{Interaction, InteractionBase, SimpleInteraction};
use crate::core::light::{LightBase, LightBounds, LightLiSample, LightSampleContext, LightTrait};
use crate::core::spectrum::SpectrumTrait;
use crate::spectra::{DenselySampledSpectrum, SampledSpectrum, SampledWavelengths};
use crate::utils::Ptr;
use crate::{Float, PI};
use crate::utils::math::square;
use crate::{Float, Ptr, PI};
use num_traits::Float as NumFloat;
#[repr(C)]
@ -42,7 +42,7 @@ impl LightTrait for DistantLight {
}
fn phi(&self, lambda: SampledWavelengths) -> SampledSpectrum {
self.scale * self.lemit.sample(&lambda) * PI * self.scene_radius.sqrt()
self.scale * self.lemit.sample(&lambda) * PI * square(self.scene_radius)
}
fn sample_li(

144
shared/src/lights/sampler.rs
View file

@ -1,8 +1,7 @@
use crate::core::geometry::primitives::OctahedralVector;
use crate::core::geometry::{Bounds3f, Normal3f, Point3f, Vector3f, VectorLike};
use crate::core::geometry::{DirectionCone, Normal};
use crate::core::light::Light;
use crate::core::light::{LightBounds, LightSampleContext};
use crate::core::geometry::{Bounds3f, DirectionCone, Normal3f, Point3f, Vector3f, VectorLike};
use crate::core::light::{Light, LightBounds, LightSampleContext};
use crate::core::LightIdx;
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::utils::math::{clamp, lerp, sample_discrete};
use crate::utils::math::{safe_sqrt, square};
@ -167,25 +166,25 @@ impl CompactLightBounds {
#[derive(Debug, Clone)]
pub struct SampledLight {
pub light: Ptr<Light>,
pub light: LightIdx,
pub p: Float,
}
impl SampledLight {
pub fn new(light: Light, p: Float) -> Self {
Self {
light: Ptr::from(&light),
p,
}
}
}
// impl SampledLight {
// pub fn new(light: Light, p: Float) -> Self {
// Self {
// light: Ptr::from(&light),
// p,
// }
// }
// }
//
#[enum_dispatch]
pub trait LightSamplerTrait {
fn sample_with_context(&self, ctx: &LightSampleContext, u: Float) -> Option<SampledLight>;
fn pmf_with_context(&self, ctx: &LightSampleContext, light: &Light) -> Float;
fn pmf_with_context(&self, ctx: &LightSampleContext, idx: LightIdx) -> Float;
fn sample(&self, u: Float) -> Option<SampledLight>;
fn pmf(&self, light: &Light) -> Float;
fn pmf(&self, idx: LightIdx) -> Float;
}
#[derive(Clone, Debug)]
@ -198,18 +197,12 @@ pub enum LightSampler {
#[derive(Clone, Debug)]
pub struct UniformLightSampler {
lights: Ptr<Light>,
lights_len: u32,
}
impl UniformLightSampler {
pub fn new(lights: Ptr<Light>, lights_len: u32) -> Self {
Self { lights, lights_len }
}
#[inline(always)]
fn light(&self, idx: usize) -> Light {
unsafe { *self.lights.add(idx) }
pub fn new(lights_len: u32) -> Self {
Self { lights_len }
}
}
@ -217,39 +210,33 @@ impl LightSamplerTrait for UniformLightSampler {
fn sample_with_context(&self, _ctx: &LightSampleContext, u: Float) -> Option<SampledLight> {
self.sample(u)
}
fn pmf_with_context(&self, _ctx: &LightSampleContext, light: &Light) -> Float {
self.pmf(light)
}
fn sample(&self, u: Float) -> Option<SampledLight> {
if self.lights_len == 0 {
return None;
}
let light_index = (u as u32 * self.lights_len).min(self.lights_len - 1) as usize;
let light_index = ((u * self.lights_len as Float) as u32).min(self.lights_len - 1);
Some(SampledLight {
light: Ptr::from(&self.light(light_index)),
p: 1. / self.lights_len as Float,
light: LightIdx(light_index),
p: 1.0 / self.lights_len as Float,
})
}
fn pmf(&self, _light: &Light) -> Float {
if self.lights_len == 0 {
return 0.;
}
1. / self.lights_len as Float
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct Alias {
pub q: Float,
pub alias: u32,
fn pmf_with_context(&self, _ctx: &LightSampleContext, _idx: LightIdx) -> Float {
self.pmf(_idx)
}
fn pmf(&self, _idx: LightIdx) -> Float {
if self.lights_len == 0 {
return 0.0;
}
1.0 / self.lights_len as Float
}
}
#[repr(C)]
#[derive(Clone, Debug, Copy)]
pub struct PowerLightSampler {
pub lights: Ptr<Light>,
pub lights_len: u32,
pub alias_table: Ptr<AliasTable>,
}
@ -262,32 +249,23 @@ impl LightSamplerTrait for PowerLightSampler {
self.sample(u)
}
fn pmf_with_context(&self, _ctx: &LightSampleContext, light: &Light) -> Float {
self.pmf(light)
fn pmf_with_context(&self, _ctx: &LightSampleContext, idx: LightIdx) -> Float {
self.pmf(idx)
}
fn sample(&self, u: Float) -> Option<SampledLight> {
if self.alias_table.size() == 0 {
return None;
}
let (light_index, pmf, _) = self.alias_table.sample(u);
let light_ref = unsafe { self.lights.add(light_index as usize) };
Some(SampledLight {
light: light_ref,
light: LightIdx(light_index),
p: pmf,
})
}
fn pmf(&self, light: &Light) -> Float {
let target = light as *const Light;
for i in 0..self.lights_len as usize {
if unsafe { self.lights.add(i) }.as_raw() == target {
return self.alias_table.pmf(i as u32);
}
}
0.0
fn pmf(&self, idx: LightIdx) -> Float {
self.alias_table.pmf(idx.0)
}
}
@ -426,15 +404,17 @@ impl LightSamplerTrait for BVHLightSampler {
fn sample_with_context(&self, ctx: &LightSampleContext, mut u: Float) -> Option<SampledLight> {
let empty_nodes = if self.nodes_len == 0 { 0. } else { 1. };
let inf_size = self.infinite_lights_len as Float;
let light_size = self.lights_len as Float;
let p_inf = inf_size / (inf_size + empty_nodes);
if u < p_inf {
u /= p_inf;
let ind = (u * light_size).min(light_size - 1.) as usize;
// sample uniformly from infinite lights; their global index equals their
// position in the infinite_lights array (infinite lights are at 0..n_inf
// in the scene lights array by construction)
let ind = (u * inf_size).min(inf_size - 1.) as u32;
let pmf = p_inf / inf_size;
return Some(SampledLight::new(self.infinite_light(ind), pmf));
return Some(SampledLight { light: LightIdx(ind), p: pmf });
}
if self.nodes_len == 0 {
@ -469,28 +449,32 @@ impl LightSamplerTrait for BVHLightSampler {
node_ind = if child == 0 { child0_idx } else { child1_idx };
} else {
if node_ind > 0 || node.light_bounds.importance(p, n, &self.all_light_bounds) > 0. {
let light_idx = node.child_or_light_index() as usize;
return Some(SampledLight::new(self.light(light_idx), pmf));
// child_or_light_index() is the global index into the scene lights array
return Some(SampledLight {
light: LightIdx(node.child_or_light_index()),
p: pmf,
});
}
return None;
}
}
}
fn pmf_with_context(&self, ctx: &LightSampleContext, light: &Light) -> Float {
fn pmf_with_context(&self, ctx: &LightSampleContext, idx: LightIdx) -> Float {
let empty_nodes = if self.nodes_len == 0 { 0. } else { 1. };
let n_infinite = self.infinite_lights_len as Float;
if self
.light_index_in(self.infinite_lights, self.infinite_lights_len, light)
.is_some()
{
// Infinite lights occupy indices 0..infinite_lights_len in the global array
if idx.0 < self.infinite_lights_len {
return 1.0 / (n_infinite + empty_nodes);
}
let Some(light_index) = self.light_index_in(self.lights, self.lights_len, light) else {
let light_index = idx.0 as usize;
if light_index >= self.lights_len as usize {
return 0.0;
};
}
// bit_trail[light_index] encodes the path from root to the leaf for this light
let mut bit_trail = self.bit_trail(light_index);
let p_inf = n_infinite / (n_infinite + empty_nodes);
let mut pmf = 1.0 - p_inf;
@ -516,17 +500,12 @@ impl LightSamplerTrait for BVHLightSampler {
}
let which_child = (bit_trail & 1) as usize;
// Update probability: prob of picking the correct child
pmf *= ci[which_child] / sum_importance;
// Advance
node_ind = if which_child == 1 {
node.child_or_light_index() as usize
} else {
node_ind + 1
};
bit_trail >>= 1;
}
}
@ -535,20 +514,17 @@ impl LightSamplerTrait for BVHLightSampler {
if self.lights_len == 0 {
return None;
}
let light_ind = (u * self.lights_len as Float).min(self.lights_len as Float - 1.) as usize;
Some(SampledLight::new(
self.light(light_ind),
1. / self.lights_len as Float,
))
let light_ind = (u * self.lights_len as Float).min(self.lights_len as Float - 1.) as u32;
Some(SampledLight {
light: LightIdx(light_ind),
p: 1. / self.lights_len as Float,
})
}
fn pmf(&self, _light: &Light) -> Float {
fn pmf(&self, _idx: LightIdx) -> Float {
if self.lights_len == 0 {
return 0.;
}
1. / self.lights_len as Float
}
}

78
shared/src/materials/coated.rs
View file

@ -8,7 +8,7 @@ use crate::core::image::Image;
use crate::core::material::{Material, MaterialEvalContext, MaterialTrait};
use crate::core::scattering::TrowbridgeReitzDistribution;
use crate::core::spectrum::{Spectrum, SpectrumTrait};
use crate::core::texture::{GPUFloatTexture, GPUSpectrumTexture, TextureEvaluator};
use crate::core::texture::{FloatTexture, SpectrumTexture, TextureEvaluator};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::utils::Ptr;
use crate::utils::math::clamp;
@ -17,13 +17,13 @@ use crate::utils::math::clamp;
#[derive(Clone, Copy, Debug)]
pub struct CoatedDiffuseMaterial {
pub normal_map: Ptr<Image>,
pub displacement: Ptr<GPUFloatTexture>,
pub reflectance: Ptr<GPUSpectrumTexture>,
pub albedo: Ptr<GPUSpectrumTexture>,
pub u_roughness: Ptr<GPUFloatTexture>,
pub v_roughness: Ptr<GPUFloatTexture>,
pub thickness: Ptr<GPUFloatTexture>,
pub g: Ptr<GPUFloatTexture>,
pub displacement: Ptr<FloatTexture>,
pub reflectance: Ptr<SpectrumTexture>,
pub albedo: Ptr<SpectrumTexture>,
pub u_roughness: Ptr<FloatTexture>,
pub v_roughness: Ptr<FloatTexture>,
pub thickness: Ptr<FloatTexture>,
pub g: Ptr<FloatTexture>,
pub eta: Ptr<Spectrum>,
pub max_depth: u32,
pub n_samples: u32,
@ -34,13 +34,13 @@ pub struct CoatedDiffuseMaterial {
impl CoatedDiffuseMaterial {
#[allow(clippy::too_many_arguments)]
pub fn new(
reflectance: Ptr<GPUSpectrumTexture>,
u_roughness: Ptr<GPUFloatTexture>,
v_roughness: Ptr<GPUFloatTexture>,
thickness: Ptr<GPUFloatTexture>,
albedo: Ptr<GPUSpectrumTexture>,
g: Ptr<GPUFloatTexture>,
displacement: Ptr<GPUFloatTexture>,
reflectance: Ptr<SpectrumTexture>,
u_roughness: Ptr<FloatTexture>,
v_roughness: Ptr<FloatTexture>,
thickness: Ptr<FloatTexture>,
albedo: Ptr<SpectrumTexture>,
g: Ptr<FloatTexture>,
displacement: Ptr<FloatTexture>,
eta: Ptr<Spectrum>,
normal_map: Ptr<Image>,
remap_roughness: bool,
@ -141,7 +141,7 @@ impl MaterialTrait for CoatedDiffuseMaterial {
Some(&*self.normal_map)
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
self.displacement
}
@ -153,18 +153,18 @@ impl MaterialTrait for CoatedDiffuseMaterial {
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct CoatedConductorMaterial {
displacement: Ptr<GPUFloatTexture>,
interface_uroughness: Ptr<GPUFloatTexture>,
interface_vroughness: Ptr<GPUFloatTexture>,
thickness: Ptr<GPUFloatTexture>,
displacement: Ptr<FloatTexture>,
interface_uroughness: Ptr<FloatTexture>,
interface_vroughness: Ptr<FloatTexture>,
thickness: Ptr<FloatTexture>,
interface_eta: Ptr<Spectrum>,
g: Ptr<GPUFloatTexture>,
albedo: Ptr<GPUSpectrumTexture>,
conductor_uroughness: Ptr<GPUFloatTexture>,
conductor_vroughness: Ptr<GPUFloatTexture>,
conductor_eta: Ptr<GPUSpectrumTexture>,
k: Ptr<GPUSpectrumTexture>,
reflectance: Ptr<GPUSpectrumTexture>,
g: Ptr<FloatTexture>,
albedo: Ptr<SpectrumTexture>,
conductor_uroughness: Ptr<FloatTexture>,
conductor_vroughness: Ptr<FloatTexture>,
conductor_eta: Ptr<SpectrumTexture>,
k: Ptr<SpectrumTexture>,
reflectance: Ptr<SpectrumTexture>,
normal_map: Ptr<Image>,
max_depth: u32,
n_samples: u32,
@ -175,17 +175,17 @@ pub struct CoatedConductorMaterial {
impl CoatedConductorMaterial {
#[allow(clippy::too_many_arguments)]
pub fn new(
displacement: Ptr<GPUFloatTexture>,
interface_uroughness: Ptr<GPUFloatTexture>,
interface_vroughness: Ptr<GPUFloatTexture>,
thickness: Ptr<GPUFloatTexture>,
g: Ptr<GPUFloatTexture>,
albedo: Ptr<GPUSpectrumTexture>,
conductor_uroughness: Ptr<GPUFloatTexture>,
conductor_vroughness: Ptr<GPUFloatTexture>,
conductor_eta: Ptr<GPUSpectrumTexture>,
k: Ptr<GPUSpectrumTexture>,
reflectance: Ptr<GPUSpectrumTexture>,
displacement: Ptr<FloatTexture>,
interface_uroughness: Ptr<FloatTexture>,
interface_vroughness: Ptr<FloatTexture>,
thickness: Ptr<FloatTexture>,
g: Ptr<FloatTexture>,
albedo: Ptr<SpectrumTexture>,
conductor_uroughness: Ptr<FloatTexture>,
conductor_vroughness: Ptr<FloatTexture>,
conductor_eta: Ptr<SpectrumTexture>,
k: Ptr<SpectrumTexture>,
reflectance: Ptr<SpectrumTexture>,
normal_map: Ptr<Image>,
interface_eta: Ptr<Spectrum>,
max_depth: u32,
@ -337,7 +337,7 @@ impl MaterialTrait for CoatedConductorMaterial {
self.normal_map.get()
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
self.displacement
}

58
shared/src/materials/complex.rs
View file

@ -10,37 +10,37 @@ use crate::core::image::Image;
use crate::core::material::{Material, MaterialEvalContext, MaterialTrait};
use crate::core::scattering::TrowbridgeReitzDistribution;
use crate::core::spectrum::{Spectrum, SpectrumTrait};
use crate::core::texture::{GPUFloatTexture, GPUSpectrumTexture, TextureEvaluator};
use crate::core::texture::{FloatTexture, SpectrumTexture, TextureEvaluator};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::textures::GPUSpectrumMixTexture;
use crate::textures::SpectrumMixTexture;
use crate::utils::Ptr;
use crate::utils::math::clamp;
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct HairMaterial {
pub sigma_a: Ptr<GPUSpectrumTexture>,
pub color: Ptr<GPUSpectrumTexture>,
pub eumelanin: Ptr<GPUFloatTexture>,
pub pheomelanin: Ptr<GPUFloatTexture>,
pub eta: Ptr<GPUFloatTexture>,
pub beta_m: Ptr<GPUFloatTexture>,
pub beta_n: Ptr<GPUFloatTexture>,
pub alpha: Ptr<GPUFloatTexture>,
pub sigma_a: Ptr<SpectrumTexture>,
pub color: Ptr<SpectrumTexture>,
pub eumelanin: Ptr<FloatTexture>,
pub pheomelanin: Ptr<FloatTexture>,
pub eta: Ptr<FloatTexture>,
pub beta_m: Ptr<FloatTexture>,
pub beta_n: Ptr<FloatTexture>,
pub alpha: Ptr<FloatTexture>,
}
impl HairMaterial {
#[cfg(not(target_os = "cuda"))]
#[allow(clippy::too_many_arguments)]
pub fn new(
sigma_a: Ptr<GPUSpectrumTexture>,
color: Ptr<GPUSpectrumTexture>,
eumelanin: Ptr<GPUFloatTexture>,
pheomelanin: Ptr<GPUFloatTexture>,
eta: Ptr<GPUFloatTexture>,
beta_m: Ptr<GPUFloatTexture>,
beta_n: Ptr<GPUFloatTexture>,
alpha: Ptr<GPUFloatTexture>,
sigma_a: Ptr<SpectrumTexture>,
color: Ptr<SpectrumTexture>,
eumelanin: Ptr<FloatTexture>,
pheomelanin: Ptr<FloatTexture>,
eta: Ptr<FloatTexture>,
beta_m: Ptr<FloatTexture>,
beta_n: Ptr<FloatTexture>,
alpha: Ptr<FloatTexture>,
) -> Self {
Self {
sigma_a,
@ -81,7 +81,7 @@ impl MaterialTrait for HairMaterial {
todo!()
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
Ptr::null()
}
@ -93,7 +93,7 @@ impl MaterialTrait for HairMaterial {
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct MeasuredMaterial {
pub displacement: Ptr<GPUFloatTexture>,
pub displacement: Ptr<FloatTexture>,
pub normal_map: Ptr<Image>,
pub brdf: Ptr<MeasuredBxDFData>,
}
@ -126,7 +126,7 @@ impl MaterialTrait for MeasuredMaterial {
Some(&*self.normal_map)
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
self.displacement
}
@ -139,15 +139,15 @@ impl MaterialTrait for MeasuredMaterial {
#[derive(Clone, Copy, Debug)]
pub struct SubsurfaceMaterial {
pub normal_map: Ptr<Image>,
pub displacement: Ptr<GPUFloatTexture>,
pub sigma_a: Ptr<GPUSpectrumTexture>,
pub sigma_s: Ptr<GPUSpectrumMixTexture>,
pub reflectance: Ptr<GPUSpectrumMixTexture>,
pub mfp: Ptr<GPUSpectrumMixTexture>,
pub displacement: Ptr<FloatTexture>,
pub sigma_a: Ptr<SpectrumTexture>,
pub sigma_s: Ptr<SpectrumMixTexture>,
pub reflectance: Ptr<SpectrumMixTexture>,
pub mfp: Ptr<SpectrumMixTexture>,
pub eta: Float,
pub scale: Float,
pub u_roughness: Ptr<GPUFloatTexture>,
pub v_roughness: Ptr<GPUFloatTexture>,
pub u_roughness: Ptr<FloatTexture>,
pub v_roughness: Ptr<FloatTexture>,
pub remap_roughness: bool,
pub table: Ptr<BSSRDFTable>,
}
@ -178,7 +178,7 @@ impl MaterialTrait for SubsurfaceMaterial {
todo!()
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
todo!()
}

28
shared/src/materials/conductor.rs
View file

@ -8,7 +8,7 @@ use crate::core::image::Image;
use crate::core::material::{Material, MaterialEvalContext, MaterialTrait};
use crate::core::scattering::TrowbridgeReitzDistribution;
use crate::core::spectrum::{Spectrum, SpectrumTrait};
use crate::core::texture::{GPUFloatTexture, GPUSpectrumTexture, TextureEvaluator};
use crate::core::texture::{FloatTexture, SpectrumTexture, TextureEvaluator};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::utils::math::clamp;
use crate::utils::Ptr;
@ -17,24 +17,24 @@ use crate::utils::Ptr;
#[derive(Clone, Copy, Debug)]
pub struct ConductorMaterial {
pub normal_map: Ptr<Image>,
pub reflectance: Ptr<GPUSpectrumTexture>,
pub eta: Ptr<GPUSpectrumTexture>,
pub k: Ptr<GPUSpectrumTexture>,
pub u_roughness: Ptr<GPUFloatTexture>,
pub v_roughness: Ptr<GPUFloatTexture>,
pub displacement: Ptr<GPUFloatTexture>,
pub reflectance: Ptr<SpectrumTexture>,
pub eta: Ptr<SpectrumTexture>,
pub k: Ptr<SpectrumTexture>,
pub u_roughness: Ptr<FloatTexture>,
pub v_roughness: Ptr<FloatTexture>,
pub displacement: Ptr<FloatTexture>,
pub remap_roughness: bool,
}
impl ConductorMaterial {
pub fn new(
normal_map: Ptr<Image>,
reflectance: Ptr<GPUSpectrumTexture>,
eta: Ptr<GPUSpectrumTexture>,
k: Ptr<GPUSpectrumTexture>,
u_roughness: Ptr<GPUFloatTexture>,
v_roughness: Ptr<GPUFloatTexture>,
displacement: Ptr<GPUFloatTexture>,
reflectance: Ptr<SpectrumTexture>,
eta: Ptr<SpectrumTexture>,
k: Ptr<SpectrumTexture>,
u_roughness: Ptr<FloatTexture>,
v_roughness: Ptr<FloatTexture>,
displacement: Ptr<FloatTexture>,
remap_roughness: bool,
) -> Self {
Self {
@ -105,7 +105,7 @@ impl MaterialTrait for ConductorMaterial {
self.normal_map.get()
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
self.displacement
}

14
shared/src/materials/dielectric.rs
View file

@ -8,7 +8,7 @@ use crate::core::image::Image;
use crate::core::material::{Material, MaterialEvalContext, MaterialTrait};
use crate::core::scattering::TrowbridgeReitzDistribution;
use crate::core::spectrum::{Spectrum, SpectrumTrait};
use crate::core::texture::{GPUFloatTexture, GPUSpectrumTexture, TextureEvaluator};
use crate::core::texture::{FloatTexture, SpectrumTexture, TextureEvaluator};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::utils::math::clamp;
use crate::Ptr;
@ -17,9 +17,9 @@ use crate::Ptr;
#[derive(Clone, Copy, Debug)]
pub struct DielectricMaterial {
pub normal_map: Ptr<Image>,
pub displacement: Ptr<GPUFloatTexture>,
pub u_roughness: Ptr<GPUFloatTexture>,
pub v_roughness: Ptr<GPUFloatTexture>,
pub displacement: Ptr<FloatTexture>,
pub u_roughness: Ptr<FloatTexture>,
pub v_roughness: Ptr<FloatTexture>,
pub eta: Ptr<Spectrum>,
pub remap_roughness: bool,
}
@ -71,7 +71,7 @@ impl MaterialTrait for DielectricMaterial {
Some(&*self.normal_map)
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
self.displacement
}
@ -83,7 +83,7 @@ impl MaterialTrait for DielectricMaterial {
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct ThinDielectricMaterial {
pub displacement: Ptr<GPUFloatTexture>,
pub displacement: Ptr<FloatTexture>,
pub normal_map: Ptr<Image>,
pub eta: Ptr<Spectrum>,
}
@ -114,7 +114,7 @@ impl MaterialTrait for ThinDielectricMaterial {
Some(&*self.normal_map)
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
self.displacement
}

23
shared/src/materials/diffuse.rs
View file

@ -1,4 +1,3 @@
use crate::Float;
use crate::bxdfs::{
CoatedConductorBxDF, CoatedDiffuseBxDF, ConductorBxDF, DielectricBxDF, DiffuseBxDF, HairBxDF,
};
@ -9,17 +8,18 @@ use crate::core::image::Image;
use crate::core::material::{Material, MaterialEvalContext, MaterialTrait};
use crate::core::scattering::TrowbridgeReitzDistribution;
use crate::core::spectrum::{Spectrum, SpectrumTrait};
use crate::core::texture::{GPUFloatTexture, GPUSpectrumTexture, TextureEvaluator};
use crate::core::texture::{FloatTexture, SpectrumTexture, TextureEvaluator};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::Ptr;
use crate::utils::math::clamp;
use crate::Float;
use crate::Ptr;
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct DiffuseMaterial {
pub normal_map: Ptr<Image>,
pub displacement: Ptr<GPUFloatTexture>,
pub reflectance: Ptr<GPUSpectrumTexture>,
pub displacement: Ptr<FloatTexture>,
pub reflectance: Ptr<SpectrumTexture>,
}
impl MaterialTrait for DiffuseMaterial {
@ -29,7 +29,8 @@ impl MaterialTrait for DiffuseMaterial {
ctx: &MaterialEvalContext,
lambda: &SampledWavelengths,
) -> BSDF {
let r = tex_eval.evaluate_spectrum(&self.reflectance, ctx, lambda);
let spec = tex_eval.evaluate_spectrum(&self.reflectance, ctx, lambda);
let r = SampledSpectrum::clamp(&spec, 0., 1.);
let bxdf = BxDF::Diffuse(DiffuseBxDF::new(r));
BSDF::new(ctx.ns, ctx.dpdus, bxdf)
}
@ -51,7 +52,7 @@ impl MaterialTrait for DiffuseMaterial {
self.normal_map.get()
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
self.displacement
}
@ -64,9 +65,9 @@ impl MaterialTrait for DiffuseMaterial {
#[derive(Clone, Copy, Debug)]
pub struct DiffuseTransmissionMaterial {
pub image: Ptr<Image>,
pub displacement: Ptr<GPUFloatTexture>,
pub reflectance: Ptr<GPUFloatTexture>,
pub transmittance: Ptr<GPUFloatTexture>,
pub displacement: Ptr<FloatTexture>,
pub reflectance: Ptr<FloatTexture>,
pub transmittance: Ptr<FloatTexture>,
pub scale: Float,
}
@ -96,7 +97,7 @@ impl MaterialTrait for DiffuseTransmissionMaterial {
self.image.get()
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
self.displacement
}

6
shared/src/materials/mix.rs
View file

@ -8,7 +8,7 @@ use crate::core::image::Image;
use crate::core::material::{Material, MaterialEvalContext, MaterialTrait};
use crate::core::scattering::TrowbridgeReitzDistribution;
use crate::core::spectrum::{Spectrum, SpectrumTrait};
use crate::core::texture::{GPUFloatTexture, GPUSpectrumTexture, TextureEvaluator};
use crate::core::texture::{FloatTexture, SpectrumTexture, TextureEvaluator};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::utils::Ptr;
use crate::utils::hash::hash_float;
@ -17,7 +17,7 @@ use crate::utils::math::clamp;
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct MixMaterial {
pub amount: Ptr<GPUFloatTexture>,
pub amount: Ptr<FloatTexture>,
pub materials: [Ptr<Material>; 2],
}
@ -73,7 +73,7 @@ impl MaterialTrait for MixMaterial {
None
}
fn get_displacement(&self) -> Ptr<GPUFloatTexture> {
fn get_displacement(&self) -> Ptr<FloatTexture> {
panic!(
"MixMaterial::get_displacement() shouldn't be called. \
Displacement is not supported on Mix materials directly."

6
shared/src/textures/checkerboard.rs
View file

@ -1,6 +1,6 @@
use crate::Float;
use crate::core::texture::{
GPUFloatTexture, GPUSpectrumTexture, TextureEvalContext, TextureMapping2D, TextureMapping3D,
FloatTexture, SpectrumTexture, TextureEvalContext, TextureMapping2D, TextureMapping3D,
TextureMapping3DTrait,
};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
@ -46,7 +46,7 @@ fn checkerboard(
pub struct FloatCheckerboardTexture {
pub map2d: Ptr<TextureMapping2D>,
pub map3d: Ptr<TextureMapping3D>,
pub tex: [Ptr<GPUFloatTexture>; 2],
pub tex: [Ptr<FloatTexture>; 2],
}
impl FloatCheckerboardTexture {
@ -77,7 +77,7 @@ impl FloatCheckerboardTexture {
pub struct SpectrumCheckerboardTexture {
pub map2d: Ptr<TextureMapping2D>,
pub map3d: Ptr<TextureMapping3D>,
pub tex: [Ptr<GPUSpectrumTexture>; 2],
pub tex: [Ptr<SpectrumTexture>; 2],
}
impl SpectrumCheckerboardTexture {

10
shared/src/textures/dots.rs
View file

@ -1,7 +1,7 @@
use crate::Float;
use crate::core::geometry::{Point2f, VectorLike};
use crate::core::texture::{
GPUFloatTexture, GPUSpectrumTexture, TextureEvalContext, TextureMapping2D,
FloatTexture, SpectrumTexture, TextureEvalContext, TextureMapping2D,
};
use crate::spectra::sampled::{SampledSpectrum, SampledWavelengths};
use crate::utils::Ptr;
@ -29,8 +29,8 @@ fn inside_polka_dot(st: Point2f) -> bool {
#[derive(Debug, Clone, Copy)]
pub struct FloatDotsTexture {
pub mapping: TextureMapping2D,
pub outside_dot: Ptr<GPUFloatTexture>,
pub inside_dot: Ptr<GPUFloatTexture>,
pub outside_dot: Ptr<FloatTexture>,
pub inside_dot: Ptr<FloatTexture>,
}
impl FloatDotsTexture {
@ -54,8 +54,8 @@ impl FloatDotsTexture {
#[derive(Clone, Copy, Debug)]
pub struct SpectrumDotsTexture {
pub mapping: TextureMapping2D,
pub outside_dot: Ptr<GPUSpectrumTexture>,
pub inside_dot: Ptr<GPUSpectrumTexture>,
pub outside_dot: Ptr<SpectrumTexture>,
pub inside_dot: Ptr<SpectrumTexture>,
}
impl SpectrumDotsTexture {

125
shared/src/textures/image.rs
View file

@ -1,5 +1,5 @@
use crate::core::color::{RGB, XYZ};
use crate::core::image::Image;
use crate::core::image::{Image, WrapMode, WrapMode2D};
use crate::core::spectrum::SpectrumTrait;
use crate::core::texture::{SpectrumType, TextureEvalContext, TextureMapping2D};
use crate::spectra::{
@ -13,87 +13,99 @@ use crate::Float;
* Leaving it here isolated, for careful handling */
#[repr(C)]
#[derive(Clone, Debug, Copy)]
pub struct GPUSpectrumImageTexture {
pub mapping: TextureMapping2D,
pub struct SpectrumImageTexture {
pub wrap_mode: WrapMode,
pub tex_obj: u64,
pub image: Ptr<Image>,
pub scale: Float,
pub invert: bool,
pub is_single_channel: bool,
pub color_space: Ptr<RGBColorSpace>,
pub spectrum_type: SpectrumType,
pub image: Ptr<Image>,
pub color_space: Ptr<RGBColorSpace>,
pub mapping: TextureMapping2D,
pub is_single_channel: bool,
pub invert: bool,
}
impl GPUSpectrumImageTexture {
#[allow(unused)]
impl SpectrumImageTexture {
pub fn evaluate(
&self,
ctx: &TextureEvalContext,
lambda: &SampledWavelengths,
) -> SampledSpectrum {
#[cfg(not(feature = "cuda"))]
{
return SampledSpectrum::zero();
}
#[cfg(feature = "cuda")]
{
use cuda_std::intrinsics;
let c = self.mapping.map(ctx);
let u = c.st.x();
let v = 1.0 - c.st.y();
if self.tex_obj != 0 {
// FUTURE: hardware sampling path.
// let c = self.mapping.map(ctx);
// let rgb = tex2d_grad(self.tex_obj, c.st, [c.dsdx,c.dtdx], [c.dsdy,c.dtdy]);
// return spectrum_from_rgb(rgb * self.scale, self.invert, self.spectrum_type, ...);
// Until then, fall through to software path below.
}
let d_p_dx = [c.dsdx, c.dtdx];
let d_p_dy = [c.dsdy, c.dtdy];
let tex_color = if self.is_single_channel {
let val = 0.;
// let val: Float =
// unsafe { intrinsics::tex2d_grad(self.tex_obj, u, v, d_p_dx, d_p_dy) };
RGB::new(val, val, val)
} else {
let val = [0., 0., 0., 0.];
// let val: [Float; 4] =
// unsafe { intrinsics::tex2d_grad(self.tex_obj, u, v, d_p_dx, d_p_dy) };
RGB::new(val[0], val[1], val[2])
let Some(image) = self.image.get() else {
return SampledSpectrum::zero();
};
let mut c = self.mapping.map(ctx);
c.st[1] = 1.0 - c.st[1]; // flip V to match pbrt convention
let mut rgb = tex_color * self.scale;
let wrap = WrapMode2D {
uv: [self.wrap_mode; 2],
};
let rgb = if image.n_channels == 1 {
let v = image.bilerp_channel_with_wrap(c.st, 0, wrap);
RGB::new(v, v, v)
} else {
RGB::new(
image.bilerp_channel_with_wrap(c.st, 0, wrap),
image.bilerp_channel_with_wrap(c.st, 1, wrap),
image.bilerp_channel_with_wrap(c.st, 2, wrap),
)
};
let mut rgb = rgb * self.scale;
if self.invert {
rgb = (RGB::new(1.0, 1.0, 1.0) - rgb).clamp_zero();
rgb = (RGB::new(1.0, 1.0, 1.0) - rgb);
}
rgb = rgb.clamp_zero();
let cs = self
.color_space
.get()
.expect("color_space must not be null");
match self.spectrum_type {
SpectrumType::Unbounded => {
RGBUnboundedSpectrum::new(&self.color_space, rgb).sample(lambda)
}
SpectrumType::Albedo => {
RGBAlbedoSpectrum::new(&self.color_space, rgb.clamp(0.0, 1.0)).sample(lambda)
}
_ => RGBIlluminantSpectrum::new(&self.color_space, rgb).sample(lambda),
}
SpectrumType::Unbounded => RGBUnboundedSpectrum::new(cs, rgb).sample(lambda),
SpectrumType::Albedo => RGBAlbedoSpectrum::new(cs, rgb.clamp(0.0, 1.0)).sample(lambda),
_ => RGBIlluminantSpectrum::new(cs, rgb).sample(lambda),
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct GPUFloatImageTexture {
pub struct FloatImageTexture {
pub image: Ptr<Image>,
pub mapping: TextureMapping2D,
pub wrap_mode: WrapMode,
pub tex_obj: u64,
pub scale: Float,
pub invert: bool,
}
impl GPUFloatImageTexture {
impl FloatImageTexture {
#[allow(unused_variables)]
pub fn evaluate(&self, ctx: &TextureEvalContext) -> Float {
#[cfg(not(feature = "cuda"))]
{
return 0.;
let wrap = WrapMode2D {
uv: [self.wrap_mode; 2],
};
let mut c = self.mapping.map(ctx);
c.st[1] = 1.0 - c.st[1];
let Some(image) = self.image.get() else { return 0. };
let v = image.bilerp_channel_with_wrap(c.st, 0, wrap);
let v = if self.invert { (1.0 - v).max(0.0) } else { v };
return v * self.scale;
}
#[cfg(feature = "cuda")]
#[allow(unused)]
{
if self.tex_obj != 0 {
use cuda_std::intrinsics;
let c = self.mapping.map(ctx);
let u = c.st.x();
@ -101,16 +113,19 @@ impl GPUFloatImageTexture {
let d_p_dx = [c.dsdx, c.dtdx];
let d_p_dy = [c.dsdy, c.dtdy];
// let val: Float = unsafe { intrinsics::tex2d_grad(self.tex_obj, u, v, d_p_dx, d_p_dy) };
let _ = (u, v, d_p_dx, d_p_dy);
let val: Float = 0.;
let result = if self.invert {
// Invert the pixel intensity
(1.0 - val).max(0.0)
} else {
val
};
let result = if self.invert { (1.0 - val).max(0.0) } else { val };
return result * self.scale;
}
// software path (no hardware texture object)
let wrap = WrapMode2D { uv: [self.wrap_mode; 2] };
let mut c = self.mapping.map(ctx);
c.st[1] = 1.0 - c.st[1];
let Some(image) = self.image.get() else { return 0. };
let v = image.bilerp_channel_with_wrap(c.st, 0, wrap);
let v = if self.invert { (1.0 - v).max(0.0) } else { v };
return v * self.scale;
}
}
}

38
shared/src/textures/mix.rs
View file

@ -1,18 +1,18 @@
use crate::Float;
use crate::core::geometry::{Vector3f, VectorLike};
use crate::core::texture::{GPUFloatTexture, GPUSpectrumTexture, TextureEvalContext};
use crate::core::texture::{FloatTexture, SpectrumTexture, TextureEvalContext};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::utils::Ptr;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GPUFloatMixTexture {
pub tex1: Ptr<GPUFloatTexture>,
pub tex2: Ptr<GPUFloatTexture>,
pub amount: Ptr<GPUFloatTexture>,
pub struct FloatMixTexture {
pub tex1: Ptr<FloatTexture>,
pub tex2: Ptr<FloatTexture>,
pub amount: Ptr<FloatTexture>,
}
impl GPUFloatMixTexture {
impl FloatMixTexture {
pub fn evaluate(&self, ctx: &TextureEvalContext) -> Float {
let amt = self.amount.get().map(|t| t.evaluate(ctx)).unwrap_or(0.0);
let t1 = if amt != 1.0 {
@ -33,13 +33,13 @@ impl GPUFloatMixTexture {
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GPUFloatDirectionMixTexture {
pub tex1: Ptr<GPUFloatTexture>,
pub tex2: Ptr<GPUFloatTexture>,
pub struct FloatDirectionMixTexture {
pub tex1: Ptr<FloatTexture>,
pub tex2: Ptr<FloatTexture>,
pub dir: Vector3f,
}
impl GPUFloatDirectionMixTexture {
impl FloatDirectionMixTexture {
pub fn evaluate(&self, ctx: &TextureEvalContext) -> Float {
let amt = self.dir.abs_dot(ctx.n.into());
let t1 = if amt != 1.0 {
@ -60,13 +60,13 @@ impl GPUFloatDirectionMixTexture {
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GPUSpectrumMixTexture {
pub tex1: Ptr<GPUSpectrumTexture>,
pub tex2: Ptr<GPUSpectrumTexture>,
pub amount: Ptr<GPUFloatTexture>,
pub struct SpectrumMixTexture {
pub tex1: Ptr<SpectrumTexture>,
pub tex2: Ptr<SpectrumTexture>,
pub amount: Ptr<FloatTexture>,
}
impl GPUSpectrumMixTexture {
impl SpectrumMixTexture {
pub fn evaluate(
&self,
ctx: &TextureEvalContext,
@ -97,13 +97,13 @@ impl GPUSpectrumMixTexture {
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GPUSpectrumDirectionMixTexture {
pub tex1: Ptr<GPUSpectrumTexture>,
pub tex2: Ptr<GPUSpectrumTexture>,
pub struct SpectrumDirectionMixTexture {
pub tex1: Ptr<SpectrumTexture>,
pub tex2: Ptr<SpectrumTexture>,
pub dir: Vector3f,
}
impl GPUSpectrumDirectionMixTexture {
impl SpectrumDirectionMixTexture {
pub fn evaluate(
&self,
ctx: &TextureEvalContext,

18
shared/src/textures/scaled.rs
View file

@ -1,16 +1,16 @@
use crate::Float;
use crate::core::texture::{GPUFloatTexture, GPUSpectrumTexture, TextureEvalContext};
use crate::core::texture::{FloatTexture, SpectrumTexture, TextureEvalContext};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
use crate::utils::Ptr;
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct GPUFloatScaledTexture {
pub tex: Ptr<GPUFloatTexture>,
pub scale: Ptr<GPUFloatTexture>,
pub struct FloatScaledTexture {
pub tex: Ptr<FloatTexture>,
pub scale: Ptr<FloatTexture>,
}
impl GPUFloatScaledTexture {
impl FloatScaledTexture {
pub fn evaluate(&self, ctx: &TextureEvalContext) -> Float {
let sc = self.scale.get().map(|t| t.evaluate(ctx)).unwrap();
if sc == 0. {
@ -22,12 +22,12 @@ impl GPUFloatScaledTexture {
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct GPUSpectrumScaledTexture {
pub tex: Ptr<GPUSpectrumTexture>,
pub scale: Ptr<GPUFloatTexture>,
pub struct SpectrumScaledTexture {
pub tex: Ptr<SpectrumTexture>,
pub scale: Ptr<FloatTexture>,
}
impl GPUSpectrumScaledTexture {
impl SpectrumScaledTexture {
pub fn evaluate(
&self,
ctx: &TextureEvalContext,

7
shared/src/wavefront/integrator.rs
View file

@ -3,6 +3,8 @@ use crate::core::film::Film;
use crate::core::filter::Filter;
use crate::core::light::Light;
use crate::core::sampler::Sampler;
use crate::core::material::Material;
use crate::core::LightIdx;
use crate::lights::sampler::LightSampler;
use crate::wavefront::aggregate::WavefrontAggregate;
use crate::wavefront::workitems::*;
@ -15,7 +17,9 @@ pub struct WavefrontPathIntegrator<A: WavefrontAggregate> {
pub max_depth: u32,
pub samples_per_pixel: u32,
pub regularize: bool,
pub infinite_lights: GVec<Ptr<Light>>,
pub lights: GVec<Light>,
pub materials: GVec<Material>,
pub infinite_lights: GVec<LightIdx>,
pub max_queue_size: u32,
pub scanlines_per_pass: u32,
pub light_sampler: LightSampler,
@ -33,4 +37,3 @@ pub struct WavefrontPathIntegrator<A: WavefrontAggregate> {
pub trait WavefrontRenderer {
fn render(&mut self);
}

16
shared/src/wavefront/workitems.rs
View file

@ -3,8 +3,8 @@ use crate::core::film::VisibleSurface;
use crate::core::geometry::{
Normal3f, Point2f, Point2i, Point3f, Point3fi, Ray, RayDifferential, Vector3f,
};
use crate::core::light::Light;
use crate::core::light::LightSampleContext;
use crate::core::light::{Light, LightSampleContext};
use crate::core::{MaterialIdx, LightIdx};
use crate::core::material::Material;
use crate::core::medium::{Medium, MediumInterface};
use crate::spectra::{SampledSpectrum, SampledWavelengths};
@ -207,7 +207,7 @@ impl SoA for EscapedRayWorkItemSoA {
#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct HitAreaLightWorkItem {
pub area_light: Ptr<Light>,
pub area_light: LightIdx,
pub p: Point3f,
pub n: Normal3f,
pub uv: Point2f,
@ -225,7 +225,7 @@ pub struct HitAreaLightWorkItem {
#[repr(C)]
#[derive(Clone, Copy)]
pub struct HitAreaLightWorkItemSoA {
pub area_light: SoABuffer<Ptr<Light>>,
pub area_light: SoABuffer<LightIdx>,
pub p: SoABuffer<Point3f>,
pub n: SoABuffer<Normal3f>,
pub uv: SoABuffer<Point2f>,
@ -308,8 +308,8 @@ pub struct MaterialEvalWorkItem {
pub wo: Vector3f,
pub time: Float,
pub face_index: i32,
pub material: Ptr<Material>,
pub area_light: Ptr<Light>,
pub material: MaterialIdx,
pub area_light: LightIdx,
pub medium_interface: MediumInterface,
pub pixel_index: u32,
pub lambda: SampledWavelengths,
@ -336,8 +336,8 @@ pub struct MaterialEvalWorkItemSoA {
pub wo: SoABuffer<Vector3f>,
pub time: SoABuffer<Float>,
pub face_index: SoABuffer<i32>,
pub material: SoABuffer<Ptr<Material>>,
pub area_light: SoABuffer<Ptr<Light>>,
pub material: SoABuffer<MaterialIdx>,
pub area_light: SoABuffer<LightIdx>,
pub medium_interface: SoABuffer<MediumInterface>,
pub pixel_index: SoABuffer<u32>,
pub lambda: SoABuffer<SampledWavelengths>,

22
src/core/interaction.rs
View file

@ -19,6 +19,7 @@ pub trait InteractionGetter {
lambda: &SampledWavelengths,
camera: &Camera,
sampler: &mut Sampler,
materials: &[Material],
) -> Option<BSDF>;
fn get_bssrdf(
@ -26,6 +27,7 @@ pub trait InteractionGetter {
_ray: &Ray,
lambda: &SampledWavelengths,
_camera: &Camera,
materials: &[Material],
) -> Option<BSSRDF>;
}
@ -36,18 +38,20 @@ impl InteractionGetter for SurfaceInteraction {
lambda: &SampledWavelengths,
camera: &Camera,
sampler: &mut Sampler,
materials: &[Material],
) -> Option<BSDF> {
self.compute_differentials(r, camera, sampler.samples_per_pixel());
let material = {
let Some(mut active_mat) = self.material.get() else {
if self.material.is_none() {
return None;
};
}
let mut active_mat: &Material = &materials[self.material.0 as usize];
let material = {
let tex_eval = UniversalTextureEvaluator;
while let Material::Mix(mix) = active_mat {
let ctx = MaterialEvalContext::from(&*self);
active_mat = mix.choose_material(&tex_eval, &ctx)?;
}
*active_mat
active_mat
};
let ctx = MaterialEvalContext::from(&*self);
let tex_eval = UniversalTextureEvaluator;
@ -73,10 +77,12 @@ impl InteractionGetter for SurfaceInteraction {
_ray: &Ray,
lambda: &SampledWavelengths,
_camera: &Camera,
materials: &[Material],
) -> Option<BSSRDF> {
let Some(mut active_mat) = self.material.get() else {
if self.material.is_none() {
return None;
};
}
let mut active_mat: &Material = &materials[self.material.0 as usize];
let tex_eval = UniversalTextureEvaluator;
while let Material::Mix(mix) = active_mat {
let ctx = MaterialEvalContext::from(self);
@ -95,6 +101,7 @@ impl InteractionGetter for MediumInteraction {
_lambda: &SampledWavelengths,
_camera: &Camera,
_sampler: &mut Sampler,
_materials: &[Material],
) -> Option<BSDF> {
None
}
@ -104,6 +111,7 @@ impl InteractionGetter for MediumInteraction {
_ray: &Ray,
_lambda: &SampledWavelengths,
_camera: &Camera,
_materials: &[Material],
) -> Option<BSSRDF> {
None
}
@ -116,6 +124,7 @@ impl InteractionGetter for SimpleInteraction {
_lambda: &SampledWavelengths,
_camera: &Camera,
_sampler: &mut Sampler,
_materials: &[Material],
) -> Option<BSDF> {
None
}
@ -125,6 +134,7 @@ impl InteractionGetter for SimpleInteraction {
_ray: &Ray,
_lambda: &SampledWavelengths,
_camera: &Camera,
_materials: &[Material],
) -> Option<BSSRDF> {
None
}

4
src/core/material.rs
View file

@ -88,14 +88,14 @@ impl MaterialFactory for Material {
}
pub fn default_diffuse_material(arena: &Arena) -> Material {
use shared::core::texture::GPUSpectrumTexture;
use shared::core::texture::SpectrumTexture;
use shared::core::texture::SpectrumConstantTexture;
use shared::core::spectrum::{ConstantSpectrum, Spectrum};
use shared::materials::DiffuseMaterial;
use shared::utils::Ptr;
let grey = Spectrum::Constant(ConstantSpectrum { c: 0.5 });
let tex = GPUSpectrumTexture::Constant(SpectrumConstantTexture::new(grey));
let tex = SpectrumTexture::Constant(SpectrumConstantTexture::new(grey));
let tex_ptr = arena.alloc(tex);
Material::Diffuse(DiffuseMaterial {

14
src/core/primitive.rs
View file

@ -1,16 +1,16 @@
use shared::core::{
LightIdx, MaterialIdx,
light::Light,
material::Material,
medium::MediumInterface,
primitive::{GeometricPrimitive, SimplePrimitive},
shape::Shape,
texture::GPUFloatTexture,
texture::FloatTexture,
};
use shared::utils::Ptr;
use shared::Ptr;
pub trait CreateSimplePrimitive {
fn new(shape: Ptr<Shape>, material: Ptr<Material>) -> SimplePrimitive {
fn new(shape: Ptr<Shape>, material: MaterialIdx) -> SimplePrimitive {
SimplePrimitive { shape, material }
}
}
@ -20,10 +20,10 @@ impl CreateSimplePrimitive for SimplePrimitive {}
pub trait CreateGeometricPrimitive {
fn new(
shape: Ptr<Shape>,
material: Ptr<Material>,
area_light: Ptr<Light>,
material: MaterialIdx,
area_light: LightIdx,
medium_interface: MediumInterface,
alpha: Ptr<GPUFloatTexture>,
alpha: Ptr<FloatTexture>,
) -> GeometricPrimitive {
GeometricPrimitive {
shape,

10
src/core/render.rs
View file

@ -17,7 +17,7 @@ pub fn render_scene(scene: &BasicScene, arena: &Arena) -> Result<()> {
let media = scene.create_media();
let textures = scene.create_textures(arena);
let (named_materials, materials) = scene.create_materials(&textures, arena)?;
let lights = scene.create_lights(&textures, arena);
let (lights, al_map) = scene.create_lights(&textures, &media, arena);
let _have_scattering = {
let shapes = scene.shapes.lock();
@ -30,8 +30,7 @@ pub fn render_scene(scene: &BasicScene, arena: &Arena) -> Result<()> {
.any(|sh| !sh.inside_medium.is_empty() || !sh.outside_medium.is_empty())
};
let (aggregate, area_lights) =
scene.create_aggregate(&textures, &named_materials, &materials, &media, arena);
let aggregate = scene.create_aggregate(&textures, &named_materials, &materials, al_map, &media, arena);
let mut all_lights = lights;
all_lights.extend(area_lights);
@ -60,7 +59,7 @@ pub fn render_scene(scene: &BasicScene, arena: &Arena) -> Result<()> {
loop {
if let Some(isect) = aggregate.intersect(&ray, Some(Float::INFINITY)) {
let intr = isect.intr;
if intr.material.is_null() {
if intr.material.is_none() {
log::warn!("Ignoring material")
} else {
let world_from_render = camera.base().camera_transform.world_from_render;
@ -80,7 +79,7 @@ pub fn render_scene(scene: &BasicScene, arena: &Arena) -> Result<()> {
log::debug!("Distance from camera: {}\n", intr.p().distance(cr.ray.o));
for (name, mtl) in &named_materials {
if *mtl == *intr.material.get().unwrap() {
if *mtl == intr.material {
log::debug!("Named material: {}\n\n", name);
break;
}
@ -104,6 +103,7 @@ pub fn render_scene(scene: &BasicScene, arena: &Arena) -> Result<()> {
sampler.clone(),
aggregate.clone(),
all_lights,
materials,
arena,
);
wf.render();

346
src/core/scene/scene.rs
View file

@ -15,7 +15,7 @@ use crate::lights::sampler::create_light_sampler;
use crate::utils::parallel::{run_async, AsyncJob};
use crate::utils::parameters::{NamedTextures, ParameterDictionary, TextureParameterDictionary};
use crate::utils::resolve_filename;
use crate::wavefront::{CreateWavefront, CpuAggregate, CpuWavefrontRenderer};
use crate::wavefront::{CpuAggregate, CpuWavefrontRenderer, CreateWavefront};
use crate::{Arena, ArenaUpload, FileLoc};
use anyhow::{anyhow, Result};
use parking_lot::Mutex;
@ -32,6 +32,7 @@ use shared::core::primitive::{AnimatedPrimitive, GeometricPrimitive, Primitive,
use shared::core::sampler::{Sampler, SamplerTrait};
use shared::core::shape::Shape;
use shared::core::texture::SpectrumType;
use shared::core::{LightIdx, MaterialIdx};
use shared::spectra::RGBColorSpace;
use shared::textures::FloatConstantTexture;
use shared::utils::soa::SoA;
@ -77,28 +78,30 @@ fn resolve_medium_interface(
fn resolve_material(
mat_ref: &MaterialRef,
named_materials: &HashMap<String, Material>,
named_materials: &HashMap<String, MaterialIdx>,
materials: &[Material],
loc: &FileLoc,
arena: &Arena,
) -> Material {
_arena: &Arena,
) -> MaterialIdx {
match mat_ref {
MaterialRef::Name(name) => match named_materials.get(name) {
Some(m) => *m,
None => {
log::error!("{}: named material '{}' not found", loc, name);
crate::core::material::default_diffuse_material(arena)
MaterialIdx::default()
// log::error!("{}: named material '{}' not found", loc, name);
// crate::core::material::default_diffuse_material(arena)
}
},
MaterialRef::Index(idx) => {
if *idx < materials.len() {
materials[*idx]
MaterialIdx(*idx as u32)
} else {
log::error!("{}: material index {} out of bounds", loc, idx);
crate::core::material::default_diffuse_material(arena)
MaterialIdx::default()
// log::error!("{}: material index {} out of bounds", loc, idx);
// crate::core::material::default_diffuse_material(arena)
}
}
MaterialRef::None => crate::core::material::default_diffuse_material(arena),
MaterialRef::None => MaterialIdx::default(),
}
}
@ -155,6 +158,8 @@ impl Default for BasicScene {
}
}
pub type AreaLightMap = HashMap<(usize, usize), LightIdx>;
impl BasicScene {
pub fn new() -> Self {
Self {
@ -295,26 +300,53 @@ impl BasicScene {
arena: Arc<Arena>,
) -> Result<()> {
let mut state = self.texture_state.lock();
self.add_texture_generic(
name,
texture,
&mut state,
|s| &mut s.serial_spectrum_textures,
|s| &mut s.spectrum_texture_jobs,
move |tex| {
let render_from_texture = tex.render_from_object.start_transform;
let tex_dict = TextureParameterDictionary::new(tex.base.parameters.into(), None);
if texture.render_from_object.is_animated() {
log::info!(
"{}: animated world-to-texture not supported, using start transform",
texture.base.loc
);
}
if texture.base.name != "imagemap" && texture.base.name != "ptex" {
state.serial_spectrum_textures.push((name, texture));
return Ok(());
}
let filename = resolve_filename(&texture.base.parameters.get_one_string("filename", "")?);
if !self.validate_texture_file(&filename, &texture.base.loc, &mut state.n_missing_textures)
{
return Ok(());
}
// Avoid duplicate work if the same file is already being loaded
if state.loading_texture_filenames.contains(&filename) {
state.serial_spectrum_textures.push((name, texture));
return Ok(());
}
state.loading_texture_filenames.insert(filename.clone());
state
.async_spectrum_textures
.push((name.clone(), texture.clone()));
let job = run_async(move || {
let render_from_texture = texture.render_from_object.start_transform;
let tex_dict = TextureParameterDictionary::new(texture.base.parameters.into(), None);
Arc::new(
SpectrumTexture::create(
&tex.base.name,
&texture.base.name,
render_from_texture,
tex_dict,
SpectrumType::Albedo,
tex.base.loc,
texture.base.loc,
&arena,
)
.expect("Could not create spectrum texture")
},
.expect("Could not create spectrum texture"),
)
});
state.spectrum_texture_jobs.insert(name, job);
Ok(())
}
pub fn add_area_light(&self, light: SceneEntity) -> usize {
@ -367,10 +399,39 @@ impl BasicScene {
let mut named = NamedTextures {
float_textures: Arc::new(float_textures.clone()),
albedo_spectrum_textures: Arc::new(spectrum_textures.clone()),
illuminant_spectrum_textures: Arc::new(spectrum_textures.clone()),
unbounded_spectrum_textures: Arc::new(spectrum_textures.clone()),
illuminant_spectrum_textures: Arc::new(HashMap::new()),
unbounded_spectrum_textures: Arc::new(HashMap::new()),
};
for (name, entity) in state.async_spectrum_textures.drain(..) {
let render_from_texture = entity.render_from_object.start_transform;
let params = entity.base.parameters.clone();
let unbounded = SpectrumTexture::create(
&entity.base.name,
render_from_texture,
TextureParameterDictionary::new(params.clone().into(), None),
SpectrumType::Unbounded,
entity.base.loc.clone(),
arena,
)
.expect("Could not create unbounded spectrum texture");
let illum = SpectrumTexture::create(
&entity.base.name,
render_from_texture,
TextureParameterDictionary::new(params.into(), None),
SpectrumType::Illuminant,
entity.base.loc,
arena,
)
.expect("Could not create illuminant spectrum texture");
Arc::make_mut(&mut named.unbounded_spectrum_textures)
.insert(name.clone(), Arc::new(unbounded));
Arc::make_mut(&mut named.illuminant_spectrum_textures).insert(name, Arc::new(illum));
}
// Serial float textures may reference already-loaded textures
for (name, entity) in state.serial_float_textures.drain(..) {
let render_from_texture = entity.render_from_object.start_transform;
@ -389,18 +450,30 @@ impl BasicScene {
for (name, entity) in state.serial_spectrum_textures.drain(..) {
let render_from_texture = entity.render_from_object.start_transform;
let tex_dict =
TextureParameterDictionary::new(entity.base.parameters.into(), Some(&named));
let tex = SpectrumTexture::create(
let make = |st: SpectrumType, named: &NamedTextures, loc| {
let tex_dict = TextureParameterDictionary::new(
entity.base.parameters.clone().into(),
Some(named),
);
SpectrumTexture::create(
&entity.base.name,
render_from_texture,
tex_dict,
SpectrumType::Albedo,
entity.base.loc,
st,
loc,
arena,
)
.expect("Could not create spectrum texture");
Arc::make_mut(&mut named.albedo_spectrum_textures).insert(name, Arc::new(tex));
.expect("Could not create spectrum texture")
};
let albedo = make(SpectrumType::Albedo, &named, entity.base.loc.clone());
let unbounded = make(SpectrumType::Unbounded, &named, entity.base.loc.clone());
let illum = make(SpectrumType::Illuminant, &named, entity.base.loc);
Arc::make_mut(&mut named.albedo_spectrum_textures)
.insert(name.clone(), Arc::new(albedo));
Arc::make_mut(&mut named.unbounded_spectrum_textures)
.insert(name.clone(), Arc::new(unbounded));
Arc::make_mut(&mut named.illuminant_spectrum_textures).insert(name, Arc::new(illum));
}
named
@ -517,25 +590,31 @@ impl BasicScene {
state.map.clone()
}
pub fn create_lights(&self, _textures: &NamedTextures, arena: &Arena) -> Vec<Arc<Light>> {
pub fn create_lights(
&self,
textures: &NamedTextures,
media: &HashMap<String, Arc<Medium>>,
arena: &Arena,
) -> (Vec<Light>, AreaLightMap) {
let light_state = self.light_state.lock();
let shapes = self.shapes.lock();
let film_cs = self.film_colorspace.lock();
let film_cs_ref = film_cs.as_deref();
let camera = self
.get_camera()
.expect("Camera must be initialized before lights");
let camera_transform = camera.base().camera_transform;
let mut lights: Vec<Arc<Light>> = Vec::new();
// Non-area lights created from stored entities
let mut lights: Vec<Light> = Vec::new();
for entity in &light_state.lights {
let medium = self.get_medium(&entity.medium, &entity.transformed_base.base.loc);
if entity.transformed_base.render_from_object.is_animated() {
log::warn!(
"{}: animated lights aren't supported, using start transform.",
entity.transformed_base.base.loc
);
}
match crate::core::light::create_light(
&entity.transformed_base.base.name,
entity.transformed_base.render_from_object.start_transform,
@ -545,28 +624,78 @@ impl BasicScene {
camera_transform,
arena,
) {
Ok(light) => lights.push(Arc::new(light)),
Err(e) => {
log::error!(
Ok(light) => lights.push(light), // bare Light, no Arc
Err(e) => log::error!(
"{}: failed to create light: {}",
entity.transformed_base.base.loc,
e
),
}
}
let mut area_map: AreaLightMap = HashMap::new();
for (entity_idx, entity) in shapes.iter().enumerate() {
let Some(al_idx) = entity.light_index else {
continue;
};
let al = &light_state.area_lights[al_idx];
let created_shapes = match Shape::create(
&entity.base.name,
*entity.render_from_object,
*entity.object_from_render,
entity.reverse_orientation,
entity.base.parameters.clone(),
&textures.float_textures,
entity.base.loc.clone(),
arena,
) {
Ok(s) => s,
Err(_) => continue,
};
let alpha_tex = get_alpha_texture(
&entity.base.parameters,
&entity.base.loc,
&textures.float_textures,
);
let cs = al.parameters.color_space.as_deref().or(film_cs_ref);
for (sub_idx, shape) in created_shapes.iter().enumerate() {
let default_alpha = Arc::new(FloatTexture::default());
let alpha_ref = alpha_tex.as_ref().unwrap_or(&default_alpha);
match crate::core::light::create_area_light(
*entity.render_from_object,
None,
&al.parameters,
&al.loc,
shape,
alpha_ref,
cs,
arena,
) {
Ok(light) => {
let idx = LightIdx(lights.len() as u32);
lights.push(light);
area_map.insert((entity_idx, sub_idx), idx);
}
Err(e) => log::error!("{}: area light creation failed: {}", al.loc, e),
}
}
}
lights
(lights, area_map)
}
pub fn create_aggregate(
&self,
textures: &NamedTextures,
named_materials: &HashMap<String, Material>,
named_materials: &HashMap<String, MaterialIdx>,
materials: &[Material],
area_map: &AreaLightMap,
media: &HashMap<String, Arc<Medium>>,
arena: &Arena,
) -> (Arc<Primitive>, Vec<Arc<Light>>) {
) -> Arc<Primitive> {
let mut shapes = self.shapes.lock();
let mut animated_shapes = self.animated_shapes.lock();
let mut instance_defs = self.instance_definitions.lock();
@ -575,21 +704,16 @@ impl BasicScene {
let film_cs = self.film_colorspace.lock();
let film_cs_ref = film_cs.as_deref();
let mut all_lights: Vec<Arc<Light>> = Vec::new();
log::info!("Starting shapes");
let mut primitives = Self::create_primitives_for_shapes(
&shapes,
textures,
named_materials,
materials,
&light_state,
area_map,
media,
film_cs_ref,
arena,
&mut all_lights,
);
shapes.clear();
shapes.shrink_to_fit();
@ -598,72 +722,62 @@ impl BasicScene {
textures,
named_materials,
materials,
&light_state,
area_map,
media,
film_cs_ref,
arena,
&mut all_lights,
);
primitives.extend(animated_primitives);
animated_shapes.clear();
animated_shapes.shrink_to_fit();
log::info!("Finished shapes");
log::info!("Starting instances");
let mut resolved_defs: HashMap<String, Option<Primitive>> = HashMap::new();
for (name, def) in instance_defs.drain() {
let mut inst_prims = Self::create_primitives_for_shapes(
&def.shapes,
textures,
named_materials,
materials,
&light_state,
area_map,
media,
film_cs_ref,
arena,
&mut all_lights,
);
let animated_inst_prims = Self::create_primitives_for_animated_shapes(
&def.animated_shapes,
textures,
named_materials,
materials,
&light_state,
area_map,
media,
film_cs_ref,
arena,
&mut all_lights,
);
inst_prims.extend(animated_inst_prims);
let aggregate = if inst_prims.len() > 1 {
let bvh = BVHAggregate::new(inst_prims, 4, SplitMethod::SAH);
Some(Primitive::BVH(arena.alloc(bvh)))
Some(Primitive::BVH(arena.alloc(BVHAggregate::new(
inst_prims,
4,
SplitMethod::SAH,
))))
} else if inst_prims.len() == 1 {
Some(inst_prims.into_iter().next().unwrap())
} else {
None
};
resolved_defs.insert(name, aggregate);
}
for inst in instances.drain(..) {
let def = match resolved_defs.get(&inst.name) {
Some(Some(prim)) => prim,
Some(None) => continue, // empty instance
Some(None) => continue,
None => {
log::error!("{}: object instance '{}' not defined", inst.loc, inst.name);
continue;
}
};
let prim = match &inst.transform {
InstanceTransform::Static(xform) => {
// TransformedPrimitive wraps a primitive with a static transform
Primitive::Transformed(shared::core::primitive::TransformedPrimitive {
primitive: arena.alloc(*def),
render_from_primitive: arena.alloc(**xform),
@ -676,7 +790,6 @@ impl BasicScene {
};
primitives.push(prim);
}
log::info!("Finished instances");
log::info!("Starting top-level accelerator");
@ -688,7 +801,7 @@ impl BasicScene {
let agg_ptr = arena.alloc(aggregate);
log::info!("Finished top-level accelerator");
(Arc::new(Primitive::BVH(agg_ptr)), all_lights)
Arc::new(Primitive::BVH(agg_ptr))
}
// Integrator
@ -723,12 +836,21 @@ impl BasicScene {
camera: Arc<Camera>,
sampler: Arc<Sampler>,
aggregate: Arc<Primitive>,
lights: Vec<Arc<Light>>,
lights: Vec<Light>,
materials: Vec<Material>,
arena: &Arena,
) -> CpuWavefrontRenderer {
let integrator_entity = self.integrator.lock().clone().unwrap();
let params = &integrator_entity.parameters;
CpuWavefrontRenderer::create(params.clone(), camera, sampler, aggregate, lights, arena)
CpuWavefrontRenderer::create(
params.clone(),
camera,
sampler,
aggregate,
lights,
materials,
arena,
)
}
// Getters
@ -769,17 +891,15 @@ impl BasicScene {
fn create_primitives_for_shapes(
shapes: &[ShapeSceneEntity],
textures: &NamedTextures,
named_materials: &HashMap<String, Material>,
named_materials: &HashMap<String, MaterialIdx>,
materials: &[Material],
light_state: &LightState,
area_map: &AreaLightMap,
media: &HashMap<String, Arc<Medium>>,
film_cs: Option<&RGBColorSpace>,
arena: &Arena,
area_lights: &mut Vec<Arc<Light>>,
) -> Vec<Primitive> {
let mut primitives = Vec::new();
for entity in shapes {
for (entity_idx, entity) in shapes.iter().enumerate() {
let created_shapes = match Shape::create(
&entity.base.name,
*entity.render_from_object,
@ -801,22 +921,18 @@ impl BasicScene {
continue;
}
eprintln!("shape '{}' n={}", entity.base.name, created_shapes.len());
let mtl = resolve_material(
let mtl: MaterialIdx = resolve_material(
&entity.material,
named_materials,
materials,
&entity.base.loc,
arena,
);
let alpha_tex = get_alpha_texture(
&entity.base.parameters,
&entity.base.loc,
&textures.float_textures,
);
let mi = resolve_medium_interface(
media,
&entity.inside_medium,
@ -824,73 +940,39 @@ impl BasicScene {
&entity.base.loc,
);
let al_entity = entity.light_index.map(|idx| &light_state.area_lights[idx]);
for (sub_idx, shape) in created_shapes.into_iter().enumerate() {
// look up the pre-created light index instead of creating one
let light_idx = area_map
.get(&(entity_idx, sub_idx))
.copied()
.unwrap_or(LightIdx::NONE);
for shape in created_shapes {
// Create area light for this shape if the entity has one
let light_ptr = al_entity
.and_then(|al| {
let cs = al.parameters.color_space.as_deref().or(film_cs);
let default_alpha = Arc::new(FloatTexture::default());
let alpha_ref = alpha_tex.as_ref().unwrap_or(&default_alpha);
match crate::core::light::create_area_light(
*entity.render_from_object,
None,
&al.parameters,
&al.loc,
&shape,
alpha_ref,
cs,
arena,
) {
Ok(light) => {
area_lights.push(Arc::new(light));
Some(arena.alloc(light))
}
Err(e) => {
log::error!("{}: area light creation failed: {}", al.loc, e);
None
}
}
})
.unwrap_or(Ptr::null());
// Pick SimplePrimitive when no extras are needed
let prim =
if light_ptr.is_null() && !mi.is_medium_transition() && alpha_tex.is_none() {
Primitive::Simple(SimplePrimitive::new(shape, arena.alloc(mtl)))
if light_idx.is_none() && !mi.is_medium_transition() && alpha_tex.is_none() {
Primitive::Simple(SimplePrimitive::new(shape, mtl)) // mtl is MaterialIdx now
} else {
let alpha_ptr = alpha_tex
.as_ref()
.map(|t| arena.upload(t.as_ref()))
.unwrap_or(Ptr::null());
Primitive::Geometric(GeometricPrimitive::new(
shape,
arena.alloc(mtl),
light_ptr,
mi,
alpha_ptr,
shape, mtl, light_idx, mi, alpha_ptr,
))
};
primitives.push(prim);
}
}
primitives
}
fn create_primitives_for_animated_shapes(
shapes: &[AnimatedShapeSceneEntity],
textures: &NamedTextures,
named_materials: &HashMap<String, Material>,
named_materials: &HashMap<String, MaterialIdx>,
materials: &[Material],
light_state: &LightState,
area_map: &AreaLightMap,
media: &HashMap<String, Arc<Medium>>,
_film_cs: Option<&RGBColorSpace>,
arena: &Arena,
_area_lights: &mut Vec<Arc<Light>>,
) -> Vec<Primitive> {
let mut primitives = Vec::new();
@ -943,9 +1025,7 @@ impl BasicScene {
&entity.transformed_base.base.loc,
);
let al_entity = entity.light_index.map(|idx| &light_state.area_lights[idx]);
if al_entity.is_some() {
if entity.light_index.is_some() {
log::error!(
"{}: animated area lights are not supported.",
entity.transformed_base.base.loc
@ -956,7 +1036,7 @@ impl BasicScene {
let mut base_prims = Vec::new();
for shape in created_shapes {
let base = if !mi.is_medium_transition() && alpha_tex.is_none() {
Primitive::Simple(SimplePrimitive::new(shape, arena.alloc(mtl)))
Primitive::Simple(SimplePrimitive::new(shape, mtl))
} else {
let alpha_ptr = alpha_tex
.as_ref()
@ -965,8 +1045,8 @@ impl BasicScene {
Primitive::Geometric(GeometricPrimitive::new(
shape,
arena.alloc(mtl),
Ptr::null(), // no area light on animated shapes
mtl,
LightIdx::default(), // no area light on animated shapes
mi,
alpha_ptr,
))

16
src/core/texture.rs
View file

@ -12,7 +12,11 @@ use shared::core::texture::{
UVMapping,
};
use shared::spectra::{SampledSpectrum, SampledWavelengths};
use shared::textures::*;
use shared::textures::{
FBmTexture, FloatBilerpTexture, FloatCheckerboardTexture, FloatConstantTexture,
FloatDotsTexture, MarbleTexture, SpectrumBilerpTexture, SpectrumCheckerboardTexture,
SpectrumConstantTexture, SpectrumDotsTexture, WindyTexture, WrinkledTexture,
};
use shared::utils::Transform;
use shared::Float;
use std::collections::HashMap;
@ -45,16 +49,6 @@ pub enum FloatTexture {
Bilerp(FloatBilerpTexture),
}
impl FloatTexture {
fn upload_image(inner: &FloatImageTexture, _arena: &Arena) -> GPUFloatImageTexture {
GPUFloatImageTexture {
mapping: inner.base.mapping,
tex_obj: inner.base.mipmap.texture_object(),
scale: inner.base.scale,
invert: inner.base.invert,
}
}
}
impl Default for FloatTexture {
fn default() -> Self {

2
src/integrators/path.rs
View file

@ -233,7 +233,7 @@ impl RayIntegratorTrait for PathIntegrator {
if state.depth == 0 || state.specular_bounce {
state.l += state.beta * le;
} else if self.config.use_mis
&& !isect.area_light.is_null() {
&& !isect.area_light.is_none() {
let light = &isect.area_light;
let p_l = self.sampler.pmf_with_context(&state.prev_ctx, light)
* light.pdf_li(&state.prev_ctx, ray.d, true);

8
src/lights/diffuse.rs
View file

@ -1,7 +1,6 @@
use crate::core::image::{HostImage, ImageIO};
use crate::core::light::lookup_spectrum;
use crate::core::spectrum::spectrum_to_photometric;
use crate::core::texture::FloatTexture;
use crate::utils::resolve_filename;
use crate::utils::upload::ArenaUpload;
use crate::{Arena, FileLoc, ParameterDictionary};
@ -11,7 +10,8 @@ use shared::core::light::{Light, LightBase, LightType};
use shared::core::medium::{Medium, MediumInterface};
use shared::core::shape::{Shape, ShapeTrait};
use shared::core::spectrum::Spectrum;
use shared::core::texture::{GPUFloatTexture, SpectrumType, TextureEvalContext};
use crate::core::texture::FloatTexture as HostFloatTexture;
use shared::core::texture::{FloatTexture, SpectrumType, TextureEvalContext};
use shared::lights::DiffuseAreaLight;
use shared::spectra::RGBColorSpace;
use shared::utils::Transform;
@ -24,7 +24,7 @@ pub fn create(
params: &ParameterDictionary,
loc: &FileLoc,
shape: &Shape,
alpha: &FloatTexture,
alpha: &HostFloatTexture,
colorspace: Option<&RGBColorSpace>,
arena: &Arena,
) -> Result<Light> {
@ -102,7 +102,7 @@ pub fn create(
// Upload alpha texture to GPU and check for null texture
let alpha_ptr = arena.upload(alpha);
let light_type = match alpha_ptr.get().unwrap() {
GPUFloatTexture::Constant(t) if t.evaluate(&TextureEvalContext::default()) == 0.0 => {
FloatTexture::Constant(t) if t.evaluate(&TextureEvalContext::default()) == 0.0 => {
LightType::DeltaPosition
}
_ => LightType::Area,

56
src/lights/sampler.rs
View file

@ -1,65 +1,40 @@
use crate::Arena;
use shared::core::light::{Light, LightTrait};
use shared::lights::sampler::{
LightSampler, PowerLightSampler, UniformLightSampler,
};
use shared::utils::sampling::AliasTable;
use shared::lights::sampler::{LightSampler, PowerLightSampler, UniformLightSampler};
use shared::spectra::{SampledSpectrum, SampledWavelengths};
use shared::utils::sampling::AliasTable;
use shared::utils::Ptr;
use shared::Float;
use std::sync::Arc;
pub fn create_light_sampler(
name: &str,
lights: &[Arc<Light>],
arena: &Arena,
) -> LightSampler {
let device_lights = lights_to_slice(lights, arena);
pub fn create_light_sampler(name: &str, lights: &[Light], arena: &Arena) -> LightSampler {
match name {
"uniform" => LightSampler::Uniform(create_uniform(device_lights, lights.len())),
"power" => LightSampler::Power(create_power(lights, device_lights, arena)),
"uniform" => LightSampler::Uniform(create_uniform(lights.len() as u32)),
"power" => LightSampler::Power(create_power(lights, arena)),
"bvh" => {
log::warn!("BVH light sampler not yet implemented, falling back to power");
LightSampler::Power(create_power(lights, device_lights, arena))
LightSampler::Power(create_power(lights, arena))
}
_ => {
log::error!("Unknown light sampler \"{}\", using power", name);
LightSampler::Power(create_power(lights, device_lights, arena))
LightSampler::Power(create_power(lights, arena))
}
}
}
fn lights_to_slice(lights: &[Arc<Light>], arena: &Arena) -> (Ptr<Light>, u32) {
fn create_uniform(lights_len: u32) -> UniformLightSampler {
UniformLightSampler::new(lights_len)
}
fn create_power(lights: &[Light], arena: &Arena) -> PowerLightSampler {
if lights.is_empty() {
return (Ptr::null(), 0);
}
let vals: Vec<Light> = lights.iter().map(|l| **l).collect();
let (ptr, _) = arena.alloc_slice(&vals);
(ptr, lights.len() as u32)
}
fn create_uniform(
(lights, lights_len): (Ptr<Light>, u32),
_count: usize,
) -> UniformLightSampler {
UniformLightSampler::new(lights, lights_len)
}
fn create_power(
host_lights: &[Arc<Light>],
(lights, lights_len): (Ptr<Light>, u32),
arena: &Arena,
) -> PowerLightSampler {
if host_lights.is_empty() {
return PowerLightSampler {
lights: Ptr::null(),
lights_len: 0,
alias_table: Ptr::null(),
};
}
let lambda = SampledWavelengths::sample_visible(0.5);
let mut light_power: Vec<Float> = host_lights
let mut light_power: Vec<Float> = lights
.iter()
.map(|l| {
let phi = SampledSpectrum::safe_div(&l.phi(lambda), &lambda.pdf());
@ -67,7 +42,7 @@ fn create_power(
})
.collect();
// If all lights have zero power, treat as uniform
// If all lights have zero power, treat as uniform.
if light_power.iter().sum::<Float>() == 0.0 {
light_power.fill(1.0);
}
@ -76,8 +51,7 @@ fn create_power(
let alias_ptr = arena.alloc(alias_table);
PowerLightSampler {
lights,
lights_len,
lights_len: lights.len() as u32,
alias_table: alias_ptr,
}
}

1
src/materials/conductor.rs
View file

@ -62,7 +62,6 @@ impl CreateMaterial for ConductorMaterial {
remap_roughness,
);
arena.alloc(material);
Ok(Material::Conductor(material))
}
}

10
src/textures/image.rs
View file

@ -3,14 +3,14 @@ use crate::core::texture::{
CreateFloatTexture, CreateSpectrumTexture, FloatTexture, FloatTextureTrait, SpectrumTexture,
SpectrumTextureTrait,
};
use crate::utils::mipmap::{FilterFunction, MIPMap, MIPMapFilterOptions};
use crate::utils::{FileLoc, TextureParameterDictionary, resolve_filename};
use crate::{Arena};
use crate::utils::mipmap::{MIPMap, MIPMapFilterOptions};
use crate::utils::{resolve_filename, FileLoc, TextureParameterDictionary};
use crate::Arena;
use anyhow::Result;
use shared::core::color::RGB;
use shared::core::color::{ColorEncoding, SRGBEncoding};
use shared::core::geometry::Vector2f;
use shared::core::image::WrapMode;
use shared::core::image::{FilterFunction, WrapMode};
use shared::core::spectrum::SpectrumTrait;
use shared::core::texture::{SpectrumType, TexCoord2D, TextureEvalContext, TextureMapping2D};
use shared::spectra::{
@ -143,7 +143,7 @@ impl SpectrumTextureTrait for SpectrumImageTexture {
return RGBUnboundedSpectrum::new(&cs, rgb).sample(lambda);
}
SpectrumType::Albedo => {
return RGBAlbedoSpectrum::new(&cs, rgb).sample(lambda);
return RGBAlbedoSpectrum::new(&cs, rgb.clamp(0., 1.)).sample(lambda);
}
_ => return RGBIlluminantSpectrum::new(&cs, rgb).sample(lambda),
}

46
src/utils/mipmap.rs
View file

@ -1,7 +1,7 @@
use crate::core::image::{HostImage, ImageIO};
use shared::core::color::{ColorEncoding, RGB};
use shared::core::geometry::{Point2f, Point2i, Vector2f, VectorLike};
use shared::core::image::{WrapMode, WrapMode2D};
use shared::core::image::{WrapMode, WrapMode2D, FilterFunction};
use shared::spectra::RGBColorSpace;
use anyhow::{bail, Result};
use shared::utils::math::{lerp, safe_sqrt, square};
@ -13,39 +13,17 @@ use std::path::Path;
#[cfg(feature = "cuda")]
use std::sync::OnceLock;
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FilterFunction {
Point,
Bilinear,
Trilinear,
Ewa,
}
impl FilterFunction {
pub fn parse(name: &str) -> Result<FilterFunction> {
match name {
"ewa" | "EWA" => Ok(FilterFunction::Ewa),
"trilinear" => Ok(FilterFunction::Trilinear),
"bilinear" => Ok(FilterFunction::Bilinear),
"point" => Ok(FilterFunction::Point),
_ => bail!("Filter function unknown")
}
}
}
impl std::fmt::Display for FilterFunction {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let s = match self {
FilterFunction::Ewa => "EWA",
FilterFunction::Trilinear => "trilinear",
FilterFunction::Bilinear => "bilinear",
FilterFunction::Point => "point",
};
write!(f, "{}", s)
}
}
// impl std::fmt::Display for FilterFunction {
// fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
// let s = match self {
// FilterFunction::Ewa => "EWA",
// FilterFunction::Trilinear => "trilinear",
// FilterFunction::Bilinear => "bilinear",
// FilterFunction::Point => "point",
// };
// write!(f, "{}", s)
// }
// }
#[repr(C)]
#[derive(Debug, Clone, Copy)]

1
src/utils/parameters.rs
View file

@ -907,6 +907,7 @@ impl TextureParameterDictionary {
if let Some(tex) = map.get(tex_name) {
return Some(Arc::clone(tex));
}
panic!(
"[{:?}] Couldn't find spectrum texture named '{}'",
p.loc, tex_name

136
src/utils/upload.rs
View file

@ -1,8 +1,9 @@
use crate::core::texture::{FloatTexture, SpectrumTexture};
use crate::core::image::HostImage;
use shared::core::image::Image;
use crate::core::texture::{FloatTexture as HostFloatTexture, SpectrumTexture as HostSpectrumTexture};
use crate::spectra::default_colorspace;
use crate::Arena;
use shared::core::texture::{GPUFloatTexture, GPUSpectrumTexture};
use shared::core::image::Image;
use shared::core::texture::{FloatTexture, SpectrumTexture};
use shared::textures::*;
use shared::Ptr;
use std::sync::Arc;
@ -12,43 +13,46 @@ pub trait Upload {
fn upload(self, arena: &Arena) -> Self::Target;
}
fn convert_float(tex: &FloatTexture, arena: &Arena) -> GPUFloatTexture {
fn convert_float(tex: &HostFloatTexture, arena: &Arena) -> FloatTexture {
match tex {
FloatTexture::Constant(t) => GPUFloatTexture::Constant(*t),
FloatTexture::Bilerp(t) => GPUFloatTexture::Bilerp(*t),
FloatTexture::Checkerboard(t) => GPUFloatTexture::Checkerboard(*t),
FloatTexture::Dots(t) => GPUFloatTexture::Dots(*t),
FloatTexture::FBm(t) => GPUFloatTexture::FBm(*t),
FloatTexture::Windy(t) => GPUFloatTexture::Windy(*t),
FloatTexture::Wrinkled(t) => GPUFloatTexture::Wrinkled(*t),
HostFloatTexture::Constant(t) => FloatTexture::Constant(*t),
HostFloatTexture::Bilerp(t) => FloatTexture::Bilerp(*t),
HostFloatTexture::Checkerboard(t) => FloatTexture::Checkerboard(*t),
HostFloatTexture::Dots(t) => FloatTexture::Dots(*t),
HostFloatTexture::FBm(t) => FloatTexture::FBm(*t),
HostFloatTexture::Windy(t) => FloatTexture::Windy(*t),
HostFloatTexture::Wrinkled(t) => FloatTexture::Wrinkled(*t),
FloatTexture::Scaled(t) => {
let tex = arena.alloc(convert_float(&t.tex, arena));
let scale = arena.alloc(convert_float(&t.scale, arena));
GPUFloatTexture::Scaled(GPUFloatScaledTexture { tex, scale })
HostFloatTexture::Scaled(t) => {
let tex = arena.alloc(convert_float(t.tex.as_ref(), arena));
let scale = arena.alloc(convert_float(t.scale.as_ref(), arena));
FloatTexture::Scaled(FloatScaledTexture { tex, scale })
}
FloatTexture::Mix(t) => {
let tex1 = arena.alloc(convert_float(&t.tex1, arena));
let tex2 = arena.alloc(convert_float(&t.tex2, arena));
let amount = arena.alloc(convert_float(&t.amount, arena));
GPUFloatTexture::Mix(GPUFloatMixTexture { tex1, tex2, amount })
HostFloatTexture::Mix(t) => {
let tex1 = arena.alloc(convert_float(t.tex1.as_ref(), arena));
let tex2 = arena.alloc(convert_float(t.tex2.as_ref(), arena));
let amount = arena.alloc(convert_float(t.amount.as_ref(), arena));
FloatTexture::Mix(FloatMixTexture { tex1, tex2, amount })
}
FloatTexture::DirectionMix(t) => {
let tex1 = arena.alloc(convert_float(&t.tex1, arena));
let tex2 = arena.alloc(convert_float(&t.tex2, arena));
GPUFloatTexture::DirectionMix(GPUFloatDirectionMixTexture {
HostFloatTexture::DirectionMix(t) => {
let tex1 = arena.alloc(convert_float(t.tex1.as_ref(), arena));
let tex2 = arena.alloc(convert_float(t.tex2.as_ref(), arena));
FloatTexture::DirectionMix(FloatDirectionMixTexture {
tex1,
tex2,
dir: t.dir,
})
}
FloatTexture::Image(t) => {
HostFloatTexture::Image(t) => {
let image = arena.alloc(t.base.mipmap.base_image().inner.clone());
let tex_obj = arena.get_texture_object(&t.base.mipmap);
GPUFloatTexture::Image(GPUFloatImageTexture {
FloatTexture::Image(FloatImageTexture {
image,
mapping: t.base.mapping,
wrap_mode: t.base.mipmap.wrap_mode,
tex_obj,
scale: t.base.scale,
invert: t.base.invert,
@ -57,94 +61,92 @@ fn convert_float(tex: &FloatTexture, arena: &Arena) -> GPUFloatTexture {
}
}
fn convert_spectrum(tex: &SpectrumTexture, arena: &Arena) -> GPUSpectrumTexture {
fn convert_spectrum(tex: &HostSpectrumTexture, arena: &Arena) -> SpectrumTexture {
match tex {
SpectrumTexture::Constant(t) => GPUSpectrumTexture::Constant(*t),
SpectrumTexture::Bilerp(t) => GPUSpectrumTexture::Bilerp(*t),
SpectrumTexture::Checkerboard(t) => GPUSpectrumTexture::Checkerboard(*t),
SpectrumTexture::Dots(t) => GPUSpectrumTexture::Dots(*t),
SpectrumTexture::Marble(t) => GPUSpectrumTexture::Marble(*t),
HostSpectrumTexture::Constant(t) => SpectrumTexture::Constant(*t),
HostSpectrumTexture::Bilerp(t) => SpectrumTexture::Bilerp(*t),
HostSpectrumTexture::Checkerboard(t) => SpectrumTexture::Checkerboard(*t),
HostSpectrumTexture::Dots(t) => SpectrumTexture::Dots(*t),
HostSpectrumTexture::Marble(t) => SpectrumTexture::Marble(*t),
SpectrumTexture::Scaled(t) => {
let tex = arena.alloc(convert_spectrum(&t.tex, arena));
let scale = arena.alloc(convert_float(&t.scale, arena));
GPUSpectrumTexture::Scaled(GPUSpectrumScaledTexture { tex, scale })
HostSpectrumTexture::Scaled(t) => {
let tex = arena.alloc(convert_spectrum(t.tex.as_ref(), arena));
let scale = arena.alloc(convert_float(t.scale.as_ref(), arena));
SpectrumTexture::Scaled(SpectrumScaledTexture { tex, scale })
}
SpectrumTexture::Mix(t) => {
let tex1 = arena.alloc(convert_spectrum(&t.tex1, arena));
let tex2 = arena.alloc(convert_spectrum(&t.tex2, arena));
let amount = arena.alloc(convert_float(&t.amount, arena));
GPUSpectrumTexture::Mix(GPUSpectrumMixTexture { tex1, tex2, amount })
HostSpectrumTexture::Mix(t) => {
let tex1 = arena.alloc(convert_spectrum(t.tex1.as_ref(), arena));
let tex2 = arena.alloc(convert_spectrum(t.tex2.as_ref(), arena));
let amount = arena.alloc(convert_float(t.amount.as_ref(), arena));
SpectrumTexture::Mix(SpectrumMixTexture { tex1, tex2, amount })
}
SpectrumTexture::DirectionMix(t) => {
let tex1 = arena.alloc(convert_spectrum(&t.tex1, arena));
let tex2 = arena.alloc(convert_spectrum(&t.tex2, arena));
GPUSpectrumTexture::DirectionMix(GPUSpectrumDirectionMixTexture {
HostSpectrumTexture::DirectionMix(t) => {
let tex1 = arena.alloc(convert_spectrum(t.tex1.as_ref(), arena));
let tex2 = arena.alloc(convert_spectrum(t.tex2.as_ref(), arena));
SpectrumTexture::DirectionMix(SpectrumDirectionMixTexture {
tex1,
tex2,
dir: t.dir,
})
}
SpectrumTexture::Image(t) => {
HostSpectrumTexture::Image(t) => {
let image = arena.alloc(t.base.mipmap.base_image().inner.clone());
let tex_obj = arena.get_texture_object(&t.base.mipmap);
GPUSpectrumTexture::Image(GPUSpectrumImageTexture {
mapping: t.base.mapping,
SpectrumTexture::Image(SpectrumImageTexture {
image,
tex_obj,
wrap_mode: t.base.mipmap.wrap_mode,
color_space: arena
.alloc(t.base.mipmap.color_space.unwrap_or_else(default_colorspace)),
mapping: t.base.mapping,
scale: t.base.scale,
invert: t.base.invert,
is_single_channel: t.base.mipmap.is_single_channel(),
spectrum_type: t.spectrum_type,
color_space: arena.alloc(
t.base
.mipmap
.color_space
.unwrap_or_else(crate::spectra::default_colorspace),
),
})
}
}
}
impl Upload for Arc<FloatTexture> {
type Target = Ptr<GPUFloatTexture>;
impl Upload for Arc<HostFloatTexture> {
type Target = Ptr<FloatTexture>;
fn upload(self, arena: &Arena) -> Self::Target {
arena.alloc(convert_float(&self, arena))
}
}
impl Upload for Arc<SpectrumTexture> {
type Target = Ptr<GPUSpectrumTexture>;
impl Upload for Arc<HostSpectrumTexture> {
type Target = Ptr<SpectrumTexture>;
fn upload(self, arena: &Arena) -> Self::Target {
arena.alloc(convert_spectrum(&self, arena))
}
}
impl Upload for &FloatTexture {
type Target = Ptr<GPUFloatTexture>;
impl Upload for &HostFloatTexture {
type Target = Ptr<FloatTexture>;
fn upload(self, arena: &Arena) -> Self::Target {
arena.alloc(convert_float(self, arena))
}
}
impl Upload for &SpectrumTexture {
type Target = Ptr<GPUSpectrumTexture>;
impl Upload for &HostSpectrumTexture {
type Target = Ptr<SpectrumTexture>;
fn upload(self, arena: &Arena) -> Self::Target {
arena.alloc(convert_spectrum(self, arena))
}
}
impl Upload for Option<Arc<FloatTexture>> {
type Target = Ptr<GPUFloatTexture>;
impl Upload for Option<Arc<HostFloatTexture>> {
type Target = Ptr<FloatTexture>;
fn upload(self, arena: &Arena) -> Self::Target {
arena.alloc_opt(self.map(|v| convert_float(&v, arena)))
}
}
impl Upload for Option<Arc<SpectrumTexture>> {
type Target = Ptr<GPUSpectrumTexture>;
impl Upload for Option<Arc<HostSpectrumTexture>> {
type Target = Ptr<SpectrumTexture>;
fn upload(self, arena: &Arena) -> Self::Target {
arena.alloc_opt(self.map(|v| convert_spectrum(&v, arena)))
}

15
src/wavefront/aggregate.rs
View file

@ -3,21 +3,22 @@ use log::debug;
use rayon::prelude::*;
use shared::core::geometry::{Bounds3f, Ray, VectorLike};
use shared::core::interaction::{InteractionTrait, SurfaceInteraction};
use shared::core::material::MaterialTrait;
use shared::core::material::{Material, MaterialTrait};
use shared::core::primitive::{Primitive, PrimitiveTrait};
use shared::core::texture::BasicTextureEvaluator;
use shared::core::texture::TextureEvaluator;
use shared::wavefront::workitems::*;
use shared::wavefront::WavefrontAggregate;
use shared::{Float, Ptr};
use shared::{Float, Ptr, GVec, gvec_from_slice};
pub struct CpuAggregate {
pub aggregate: Primitive,
pub materials: GVec<Material>,
}
impl CpuAggregate {
pub fn new(aggregate: Primitive) -> Self {
Self { aggregate }
pub fn new(aggregate: Primitive, materials: &[Material]) -> Self {
Self { aggregate, materials: gvec_from_slice(materials) }
}
}
@ -70,7 +71,7 @@ impl WavefrontAggregate for CpuAggregate {
let intr = &si.intr;
// Medium transition
if intr.material.is_null() {
if intr.material.is_none() {
let mut next = r;
next.ray = intr.spawn_ray(r.ray.d);
next_ray_q.push(next);
@ -78,7 +79,7 @@ impl WavefrontAggregate for CpuAggregate {
}
// Area light hit
if !intr.area_light.is_null() {
if !intr.area_light.is_none() {
hit_area_light_q.push(HitAreaLightWorkItem {
area_light: intr.area_light,
p: intr.p(),
@ -97,7 +98,7 @@ impl WavefrontAggregate for CpuAggregate {
}
// Material eval queue dispatch
let material = *intr.material.get().unwrap();
let material = &self.materials[intr.material.0 as usize];
let eval_q = if material.can_evaluate_textures(&BasicTextureEvaluator) {
basic_eval_mtl_q
} else {

60
src/wavefront/integrator.rs
View file

@ -16,10 +16,11 @@ use shared::core::geometry::{
};
use shared::core::interaction::InteractionTrait;
use shared::core::light::{Light, LightSampleContext, LightTrait};
use shared::core::material::{MaterialEvalContext, MaterialTrait};
use shared::core::primitive::Primitive;
use shared::core::material::{Material, MaterialEvalContext, MaterialTrait};
use shared::core::primitive::{Primitive, PrimitiveTrait};
use shared::core::sampler::{get_camera_sample, CameraSample, Sampler, SamplerTrait};
use shared::core::texture::{BasicTextureEvaluator, TextureEvalContext, UniversalTextureEvaluator};
use shared::core::LightIdx;
use shared::lights::sampler::{LightSampler, LightSamplerTrait};
use shared::spectra::{SampledSpectrum, SampledWavelengths};
use shared::utils::math::square;
@ -27,7 +28,7 @@ use shared::utils::sampling::power_heuristic;
use shared::utils::soa::{SoA, SoAAllocator, WorkQueue};
use shared::wavefront::workitems::*;
use shared::wavefront::{WavefrontAggregate, WavefrontPathIntegrator, WavefrontRenderer};
use shared::{gvec, Ptr, SHADOW_EPSILON};
use shared::{gvec, gvec_from_slice, GVec, Ptr, SHADOW_EPSILON};
use std::ops::{Deref, DerefMut};
use std::sync::Arc;
@ -55,7 +56,8 @@ where
camera: Arc<Camera>,
sampler: Arc<Sampler>,
aggregate: Arc<Primitive>,
lights: Vec<Arc<Light>>,
mut lights: Vec<Light>,
materials: Vec<Material>,
arena: &Arena,
) -> CpuWavefrontRenderer {
let max_depth = parameters
@ -75,15 +77,23 @@ where
let scanlines_per_pass = (max_samples / res_x).max(1);
let max_queue_size = res_x * scanlines_per_pass;
let mut infinite_lights = gvec();
for light in &lights {
let mut infinite_lights: GVec<LightIdx> = gvec();
for (i, light) in lights.iter().enumerate() {
if light.light_type().is_infinite() {
infinite_lights.push(arena.alloc(**light));
infinite_lights.push(LightIdx(i as u32));
}
}
let cpu_aggregate = CpuAggregate::new(*aggregate);
let bounds = aggregate.bounds();
for light in &mut lights {
light.preprocess(&bounds);
}
let lights: GVec<Light> = gvec_from_slice(&lights);
let materials: GVec<Material> = gvec_from_slice(&materials);
CpuWavefrontRenderer(WavefrontPathIntegrator {
aggregate: cpu_aggregate,
camera: (*camera).clone(),
@ -94,6 +104,8 @@ where
samples_per_pixel: spp,
regularize,
infinite_lights,
lights,
materials,
max_queue_size,
scanlines_per_pass,
light_sampler,
@ -298,8 +310,8 @@ impl CpuWavefrontRenderer {
let mut l_contrib = SampledSpectrum::new(0.0);
for light_ptr in infinite_lights {
let light = light_ptr.get().unwrap();
for idx in infinite_lights {
let light = &self.lights[idx.0 as usize];
let ray = Ray::new(w.ray_o, w.ray_d, None, Ptr::null());
let le = light.le(&ray, &w.lambda);
if le.is_black() {
@ -311,7 +323,7 @@ impl CpuWavefrontRenderer {
} else {
// Compute MIS-weighted radiance contribution from infinite light
let ctx = w.prev_intr_ctx;
let light_choice_pdf = light_sampler.pmf_with_context(&ctx, light);
let light_choice_pdf = light_sampler.pmf_with_context(&ctx, *idx);
let r_l = w.r_l * light_choice_pdf * light.pdf_li(&ctx, w.ray_d, true);
l_contrib += w.beta * le / (w.r_u + r_l).average();
}
@ -333,9 +345,12 @@ impl CpuWavefrontRenderer {
let hit_area_light_queue = &self.hit_area_light_queue;
(0..n as usize).into_par_iter().for_each(|i| {
let w = unsafe { hit_area_light_queue.storage.get(i) };
let w = unsafe { hit_area_light_queue.get(i) };
if w.area_light.is_none() {
return;
}
let light = &self.lights[w.area_light.0 as usize];
let light = w.area_light.get().unwrap();
let le = light.l(w.p, w.n, w.uv, w.wo, &w.lambda);
if le.is_black() {
return;
@ -346,7 +361,7 @@ impl CpuWavefrontRenderer {
} else {
let wi = -w.wo;
let ctx = w.prev_intr_ctx;
let light_choice_pdf = light_sampler.pmf_with_context(&ctx, light);
let light_choice_pdf = light_sampler.pmf_with_context(&ctx, w.area_light);
// wi from previous interaction to this light hit
let light_pdf = light_choice_pdf * light.pdf_li(&ctx, wi, true);
let r_u = w.r_u;
@ -389,13 +404,13 @@ impl CpuWavefrontRenderer {
(0..n as usize).into_par_iter().for_each(|i| {
let w = unsafe { queue.storage.get(i) };
if w.material.is_none() {
return;
}
let material = &self.materials[w.material.0 as usize];
let pi = w.pixel_index as usize;
let rs = pixel_sample_state.samples.get(pi);
let Some(material) = w.material.get() else {
return;
};
let _is_cond = material.is_conductor();
// GetMaterialEvalContext
@ -516,12 +531,9 @@ impl CpuWavefrontRenderer {
else {
return;
};
let light = &self.lights[sampled_light.light.0 as usize];
let Some(ls) =
sampled_light
.light
.sample_li(&light_ctx, rs.direct.u, &lambda, true)
else {
let Some(ls) = light.sample_li(&light_ctx, rs.direct.u, &lambda, true) else {
return;
};
@ -540,7 +552,7 @@ impl CpuWavefrontRenderer {
let beta = w.beta * f * wi.abs_dot(ns.into());
let light_pdf = ls.pdf * sampled_light.p;
let bsdf_pdf = if sampled_light.light.light_type().is_delta_light() {
let bsdf_pdf = if light.light_type().is_delta_light() {
0.0
} else {
bsdf.pdf(wo, wi, FArgs::default())