Struct IntersectionContainer 

pub struct IntersectionContainer<T, Scalar: Float, State: SdfState<Scalar, DIM>, const DIM: usize>
where
    for<'a> &'a T: IntoIterator,
    for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,
{ /* private fields */ }

Hard intersection of N SDFs stored in some container, like a Vec for example.

See SdfContainerCombinationOperators for more information on how to use this.

Trait Implementations

impl<T: Clone, Scalar: Clone + Float, State: Clone + SdfState<Scalar, DIM>, const DIM: usize> Clone for IntersectionContainer<T, Scalar, State, DIM>

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,

fn clone(&self) -> IntersectionContainer<T, Scalar, State, DIM>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Scalar: Debug + Float, State: Debug + SdfState<Scalar, DIM>, const DIM: usize> Debug for IntersectionContainer<T, Scalar, State, DIM>

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,

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

Formats the value using the given formatter.

impl<T: Default, Scalar: Default + Float, State: Default + SdfState<Scalar, DIM>, const DIM: usize> Default for IntersectionContainer<T, Scalar, State, DIM>

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,

fn default() -> IntersectionContainer<T, Scalar, State, DIM>

Returns the “default value” for a type.

impl<T, Scalar: Float, State: SdfState<Scalar, DIM>, const DIM: usize> From<T> for IntersectionContainer<T, Scalar, State, DIM>

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Hash, Scalar: Hash + Float, State: Hash + SdfState<Scalar, DIM>, const DIM: usize> Hash for IntersectionContainer<T, Scalar, State, DIM>

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,

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

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,

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

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: 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<T: Copy, Scalar: Copy + Float, State: Copy + SdfState<Scalar, DIM>, const DIM: usize> Copy for IntersectionContainer<T, Scalar, State, DIM>

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,

impl<T: Eq, Scalar: Eq + Float, State: Eq + SdfState<Scalar, DIM>, const DIM: usize> Eq for IntersectionContainer<T, Scalar, State, DIM>

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,

impl<T, Scalar: Float, State: SdfState<Scalar, DIM>, const DIM: usize> StructuralPartialEq for IntersectionContainer<T, Scalar, State, DIM>

where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::Item: Sdf<Scalar, DIM, State = State>,