Struct HalfSpace 

pub struct HalfSpace { /* private fields */ }

A region of 3D space, specifically an open set whose border is a bisecting 2D plane.

This bisecting plane partitions 3D space into two infinite regions, the half-space is one of those regions and excludes the bisecting plane.

Each instance of this type is characterized by:

• the bisecting plane’s unit normal, normalized and pointing “inside” the half-space,
• the signed distance along the normal from the bisecting plane to the origin of 3D space.

The distance can also be seen as:

• the distance along the inverse of the normal from the origin of 3D space to the bisecting plane,
• the opposite of the distance along the normal from the origin of 3D space to the bisecting plane.

Any point p is considered to be within the HalfSpace when the length of the projection of p on the normal is greater or equal than the opposite of the distance, meaning: if the equation normal.dot(p) + distance > 0. is satisfied.

For example, the half-space containing all the points with a z-coordinate lesser or equal than 8.0 would be defined by: HalfSpace::new(Vec3::NEG_Z.extend(-8.0)). It includes all the points from the bisecting plane towards NEG_Z, and the distance from the plane to the origin is -8.0 along NEG_Z.

It is used to define a ViewFrustum, but is also a useful mathematical primitive for rendering tasks such as light computation.

Implementations

impl HalfSpace

pub fn new(normal_d: Vec4) -> HalfSpace

Constructs a HalfSpace from a 4D vector whose first 3 components represent the bisecting plane’s unit normal, and the last component is the signed distance along the normal from the plane to the origin. The constructor ensures the normal vector is normalized and the distance is appropriately scaled.

pub fn normal(&self) -> Vec3A

Returns the unit normal vector of the bisecting plane that characterizes the HalfSpace.

pub fn d(&self) -> f32

Returns the signed distance from the bisecting plane to the origin along the plane’s unit normal vector.

pub fn normal_d(&self) -> Vec4

Returns the bisecting plane’s unit normal vector and the signed distance from the plane to the origin.

pub fn intersection_point( a: HalfSpace, b: HalfSpace, c: HalfSpace, ) -> Option<Vec3>

Returns the intersection point if the three halfspaces all intersect at a single point.

Trait Implementations

impl Clone for HalfSpace

fn clone(&self) -> HalfSpace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HalfSpace

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

Formats the value using the given formatter.

impl Default for HalfSpace

fn default() -> HalfSpace

Returns the “default value” for a type.

impl FromReflect for HalfSpace

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<HalfSpace>

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 HalfSpace

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 HalfSpace

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

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

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> 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<HalfSpace>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<HalfSpace>, ) -> 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 + 'static)>

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

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

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

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

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

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

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

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

Applies a reflected value to this value.

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

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

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

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

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for HalfSpace

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

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

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

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

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 Struct for HalfSpace

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

Gets 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 + 'static)>

Gets 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 + 'static)>

Gets 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 + 'static)>

Gets 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>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

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 to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

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

Will return None if TypeInfo is not available.

impl TypePath for HalfSpace

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 HalfSpace

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for HalfSpace

impl StructuralPartialEq for HalfSpace