Struct InfinitePlane3d

pub struct InfinitePlane3d {
    pub normal: Dir3,
}

An unbounded plane in 3D space. It forms a separating surface through the origin, stretching infinitely far

Fields

normal: Dir3

The normal of the plane. The plane will be placed perpendicular to this direction

Implementations

impl InfinitePlane3d

pub fn new<T: TryInto<Dir3>>(normal: T) -> Self

where <T as TryInto<Dir3>>::Error: Debug,

Create a new InfinitePlane3d from a normal

Panics

Panics if the given normal is zero (or very close to zero), or non-finite.

pub fn from_points(a: Vec3, b: Vec3, c: Vec3) -> (Self, Vec3)

Create a new InfinitePlane3d based on three points and compute the geometric center of those points.

The direction of the plane normal is determined by the winding order of the triangular shape formed by the points.

Panics

Panics if a valid normal can not be computed, for example when the points are collinear and lie on the same line.

pub fn signed_distance( &self, isometry: impl Into<Isometry3d>, point: Vec3, ) -> f32

Computes the shortest distance between a plane transformed with the given isometry and a point. The result is a signed value; it’s positive if the point lies in the half-space that the plane’s normal vector points towards.

pub fn project_point( &self, isometry: impl Into<Isometry3d>, point: Vec3, ) -> Vec3

Injects the point into this plane transformed with the given isometry.

This projects the point orthogonally along the shortest path onto the plane.

pub fn isometry_into_xy(&self, origin: Vec3) -> Isometry3d

Computes an Isometry3d which transforms points from the plane in 3D space with the given origin to the XY-plane.

Guarantees

• the transformation is a congruence meaning it will preserve all distances and angles of the transformed geometry
• uses the least rotation possible to transform the geometry
• if two geometries are transformed with the same isometry, then the relations between them, like distances, are also preserved
• compared to projections, the transformation is lossless (up to floating point errors) reversible

Non-Guarantees

• the rotation used is generally not unique
• the orientation of the transformed geometry in the XY plane might be arbitrary, to enforce some kind of alignment the user has to use an extra transformation ontop of this one

See isometries_xy for example usescases.

pub fn isometry_from_xy(&self, origin: Vec3) -> Isometry3d

Computes an Isometry3d which transforms points from the XY-plane to this plane with the given origin.

Guarantees

• the transformation is a congruence meaning it will preserve all distances and angles of the transformed geometry
• uses the least rotation possible to transform the geometry
• if two geometries are transformed with the same isometry, then the relations between them, like distances, are also preserved
• compared to projections, the transformation is lossless (up to floating point errors) reversible

Non-Guarantees

• the rotation used is generally not unique
• the orientation of the transformed geometry in the XY plane might be arbitrary, to enforce some kind of alignment the user has to use an extra transformation ontop of this one

See isometries_xy for example usescases.

pub fn isometries_xy(&self, origin: Vec3) -> (Isometry3d, Isometry3d)

Computes both isometries which transforms points from the plane in 3D space with the given origin to the XY-plane and back.

Example

The projection and its inverse can be used to run 2D algorithms on flat shapes in 3D. The workflow would usually look like this:

let triangle_3d @ [a, b, c] = [Vec3::X, Vec3::Y, Vec3::Z];
let center = (a + b + c) / 3.0;

let plane = InfinitePlane3d::new(Vec3::ONE);

let (to_xy, from_xy) = plane.isometries_xy(center);

let triangle_2d = triangle_3d.map(|vec3| to_xy * vec3).map(|vec3| vec3.truncate());

// apply some algorithm to `triangle_2d`

let triangle_3d = triangle_2d.map(|vec2| vec2.extend(0.0)).map(|vec3| from_xy * vec3);

Trait Implementations

impl Bounded3d for InfinitePlane3d

fn aabb_3d(&self, isometry: impl Into<Isometry3d>) -> Aabb3d

Get an axis-aligned bounding box for the shape translated and rotated by the given isometry.

fn bounding_sphere(&self, isometry: impl Into<Isometry3d>) -> BoundingSphere

Get a bounding sphere for the shape translated and rotated by the given isometry.

impl Clone for InfinitePlane3d

fn clone(&self) -> InfinitePlane3d

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InfinitePlane3d

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

Formats the value using the given formatter.

impl Default for InfinitePlane3d

fn default() -> Self

Returns the default InfinitePlane3d with a normal pointing in the +Y direction.

impl<'de> Deserialize<'de> for InfinitePlane3d

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromReflect for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl PartialEq for InfinitePlane3d

fn eq(&self, other: &InfinitePlane3d) -> 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 PartialReflect for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

Clones the value as a Reflect trait object.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Serialize for InfinitePlane3d

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for InfinitePlane3d

where InfinitePlane3d: Any + Send + Sync, Dir3: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for InfinitePlane3d

impl Primitive3d for InfinitePlane3d

impl StructuralPartialEq for InfinitePlane3d