Struct Union 

pub struct Union<Lhs, Rhs, Scalar: Float, State: SdfState<Scalar, DIM>, const DIM: usize>
where
    Lhs: Sdf<Scalar, DIM, State = State>,
    Rhs: Sdf<Scalar, DIM, State = State>,
{ /* private fields */ }

Hard union of two SDFs.

See crate::combinators::SdfCombinationOperations for more information on how to use this.

Implementations

impl<Lhs, Rhs, Scalar: Float, State: SdfState<Scalar, DIM>, const DIM: usize> Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State>, Rhs: Sdf<Scalar, DIM, State = State>,

pub const fn new(lhs: Lhs, rhs: Rhs) -> Self

Trait Implementations

impl<Lhs, Rhs, Scalar: Clone + Float, State: Clone + SdfState<Scalar, DIM>, const DIM: usize> Clone for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State> + Clone, Rhs: Sdf<Scalar, DIM, State = State> + Clone,

fn clone(&self) -> Union<Lhs, Rhs, Scalar, State, DIM>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Lhs, Rhs, Scalar: Debug + Float, State: Debug + SdfState<Scalar, DIM>, const DIM: usize> Debug for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State> + Debug, Rhs: Sdf<Scalar, DIM, State = State> + Debug,

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

Formats the value using the given formatter.

impl<Lhs, Rhs, Scalar: Default + Float, State: Default + SdfState<Scalar, DIM>, const DIM: usize> Default for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State> + Default, Rhs: Sdf<Scalar, DIM, State = State> + Default,

fn default() -> Union<Lhs, Rhs, Scalar, State, DIM>

Returns the “default value” for a type.

impl<Lhs, Rhs, Scalar: Hash + Float, State: Hash + SdfState<Scalar, DIM>, const DIM: usize> Hash for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State> + Hash, Rhs: Sdf<Scalar, DIM, State = State> + Hash,

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<Lhs, Rhs, Scalar: PartialEq + Float, State: PartialEq + SdfState<Scalar, DIM>, const DIM: usize> PartialEq for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State> + PartialEq, Rhs: Sdf<Scalar, DIM, State = State> + PartialEq,

fn eq(&self, other: &Union<Lhs, Rhs, Scalar, State, DIM>) -> 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<Lhs, Rhs, Scalar: Float, State: SdfState<Scalar, DIM>, const DIM: usize> Sdf<Scalar, DIM> for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State>, Rhs: Sdf<Scalar, DIM, State = State>,

type State = 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, position: [Scalar; DIM]) -> Self::State

Evaluates 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 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 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_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 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<Lhs, Rhs, Scalar: Copy + Float, State: Copy + SdfState<Scalar, DIM>, const DIM: usize> Copy for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State> + Copy, Rhs: Sdf<Scalar, DIM, State = State> + Copy,

impl<Lhs, Rhs, Scalar: Eq + Float, State: Eq + SdfState<Scalar, DIM>, const DIM: usize> Eq for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State> + Eq, Rhs: Sdf<Scalar, DIM, State = State> + Eq,

impl<Lhs, Rhs, Scalar: Float, State: SdfState<Scalar, DIM>, const DIM: usize> StructuralPartialEq for Union<Lhs, Rhs, Scalar, State, DIM>

where Lhs: Sdf<Scalar, DIM, State = State>, Rhs: Sdf<Scalar, DIM, State = State>,