Struct Cube 

pub struct Cube;

A N dimension cube of side length 1.

If we need a rectangle, see Cuboid. This primitive is centered at the origin, and has side lengths of 1.

It implements Sdf<Scalar, DIM, State = ()>.

Example

use lightwalk::prelude::*;

let sdf = Cube;

// This is required to hint the dimension and scalar type of the SDF. In practice,
// the compiler probably already has enough information to go off of.
let distance = sdf.distance([1.0, 2.0]);

Trait Implementations

impl Clone for Cube

fn clone(&self) -> Cube

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cube

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Cube

fn default() -> Cube

Returns the “default value” for a type.

impl Hash for Cube

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Cube

fn eq(&self, other: &Cube) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Scalar: Float, const DIM: usize> Sdf<Scalar, DIM> for Cube

type State = ()

The state that is bound to this SDF. See SdfState for more information.

fn distance(&self, position: [Scalar; DIM]) -> Scalar

Evaluates the SDF at some point

fn state(&self, _: [Scalar; DIM])

Evaluates the state of the SDF at some point. See SdfState for more information.

fn state_sample( &self, position: [Scalar; DIM], ) -> <Self::State as SdfState<Scalar, DIM>>::Sample

Evaluates, then samples the state of the SDF at some point. See SdfState for more information.

fn distance_and_state(&self, position: [Scalar; DIM]) -> (Scalar, Self::State)

Evaluates both the distance and the state of the SDF, hopefully a little bit faster than if you called both Sdf::distance and Sdf::state separately.

fn distance_and_state_sample( &self, position: [Scalar; DIM], ) -> (Scalar, <Self::State as SdfState<Scalar, DIM>>::Sample)

Evaluates both the distance and the sample of the state of the SDF, hopefully a little bit faster than if you called both Sdf::distance and Sdf::state_sample separately.

fn gradient(&self, position: [Scalar; DIM], epsilon: Scalar) -> [Scalar; DIM]

Calculates the gradient of the SDF at some point in space. Some SDF have analytical expressions of the gradient, some don’t. If a SDF doesn’t have an implementation, it will instead approximate it using epsilon.

fn normal(&self, position: [Scalar; DIM], epsilon: Scalar) -> [Scalar; DIM]

Calculates the gradient, then normalizes it. The gradient typically is already normalized if the SDF is well formed and if we aren’t on some edge case, but we never know. Smooth combinations and the empty SDF are good counter examples.

fn normal_or_zero( &self, position: [Scalar; DIM], epsilon: Scalar, ) -> [Scalar; DIM]

Calculates the gradient, then normalizes it. If the norm is 0, then [0; DIM] is returned. The gradient typically is already normalized, but sometimes this isn’t the case, for example with the empty SDF.

fn gradient_approx( &self, position: [Scalar; DIM], epsilon: Scalar, ) -> [Scalar; DIM]

Calculates the gradient of the SDF at some point in space. It will approximate it using epsilon.

fn normal_approx( &self, position: [Scalar; DIM], epsilon: Scalar, ) -> [Scalar; DIM]

Calculates the normal of the SDF at some point in space. It will approximate the gradient using epsilon.

fn normal_or_zero_approx( &self, position: [Scalar; DIM], epsilon: Scalar, ) -> [Scalar; DIM]

Calculates the normal of the SDF at some point in space, and if the norm is 0, it will simply return [0; DIM]. It will approximate the gradient using epsilon.

impl Copy for Cube

impl Eq for Cube

impl StructuralPartialEq for Cube