Struct Sampler 

pub struct Sampler<T: Copy, R: Rng> { /* private fields */ }

Wrapper for a bounded stocastically sampled value

a Sampler encloses the distribution function and bounds for a random variable of type T, such that is can be sampled with an external random number generator of type R

Several constructors are provided for common distributions of values, however if a custom one is needed it can be provided as a closure and set of bounds to Sampler::from_fn

Implementations

impl<T, R> Sampler<T, R>

where R: Rng, T: Copy + Send + Sync + 'static,

pub fn new_const<A>(c: A) -> Self

where A: Into<T>,

Creates a new Sampler with a constant distibution.

When sampled the Sampler will always return c

impl<T, R> Sampler<T, R>

where R: Rng, T: Copy + Float + SampleUniform + Send + Sync + 'static,

pub fn new_range<A, B>(a: A, b: B) -> Self

where A: Into<T>, B: Into<T>,

Creates a new Sampler with a uniform distibution.

When sampled the Sampler will always return a value between a and b (inclusive)

impl<T, R> Sampler<T, R>

where R: Rng, T: Copy + Float + From<f32> + Send + Sync + 'static, StandardNormal: Distribution<T>,

pub fn new_gaussian<A, B>(mean: A, std_dev: B) -> Self

where A: Copy + Into<T>, B: Copy + Into<T>,

Creates a new Sampler with a normal (gaussian) distibution.

Real gaussian’s have infinate bounds, this can cause problems in the raytracing engine, so this implementation wraps at 3 standard deviations.

When sampled the Sampler will always return a value between mean - 3 * std_dev and mean + 3 * std_dev (inclusive)

impl<T, R> Sampler<T, R>

where R: Rng, T: Copy + Float + SampleUniform + FromPrimitive + From<f32> + Send + Sync + 'static,

pub fn new_blackbody<A>(temperature: A) -> Self

where A: Into<T>,

Creates a new Sampler with a blackbody radiation curve distibution.

This is only really useful for creating realistic white lights of a given colour temprature, or stars.

This sampler should be used carefully; it can lead to unexpected results when used on a value other than Light.wavelength. It is also substancially slower than the other Sampler types. When Sampled it will return a value between 0 and T::MAX (probably larger than you want) This can cause all sorts of weird problems for collision detection, so please don’t use this on a SamplerPoint

impl<T, R> Sampler<T, R>

where T: Copy, R: Rng,

pub fn from_fn( f: Arc<dyn Fn(&mut R) -> T + Send + Sync>, lower: T, upper: T, ) -> Self

Creates a new Sampler with a distribution dictated by f

f must always return a value within the bounds specified by lower & upper

This is very low level access to how the renderer works; you’re in control, if you break it it’s your fault!

pub fn sample(&self, rng: &mut R) -> T

Get a sampled value from this Sampler using random number generator rng

pub fn bounds(&self) -> (T, T)

Get the bounds of a possible sampled value (useful for spacial partitioning and limit checks etc)

Trait Implementations

impl<T: Clone + Copy, R: Clone + Rng> Clone for Sampler<T, R>

fn clone(&self) -> Sampler<T, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, R> From<(T, T)> for Sampler<T, R>

where T: Copy + Float + SampleUniform + Send + Sync + From<f32> + 'static, R: Rng,

A tuple of type (T,T) will be interpreted as a uniform distribution if turned into a sampler.

Example:

extern crate rand;

use rustic_zen::sampler::Sampler;
use rand::prelude::*;
let mut r = rand::thread_rng();

let s: Sampler<f64, ThreadRng> = (5.0,10.0).into();

assert!(s.sample(&mut r) >= 5.0); // will always be true
assert!(s.sample(&mut r) <= 10.0); // will always be true

fn from(value: (T, T)) -> Self

Converts to this type from the input type.

impl<T, R> From<T> for Sampler<T, R>

where T: Copy + From<T> + Send + Sync + 'static, R: Rng,

A single value of type T will be interpreted as a constant distribution if turned into a sampler.

Example:

extern crate rand;

use rustic_zen::sampler::Sampler;
use rand::prelude::*;
let mut r = rand::thread_rng();

let s: Sampler<f64, ThreadRng> = 5.0.into();

assert_eq!(s.sample(&mut r), 5.0); // will always be true

fn from(value: T) -> Self

Converts to this type from the input type.