Struct gdnative::core_types::Plane

#[repr(C)]
pub struct Plane {
    pub normal: Vector3,
    pub d: f32,
}

3D plane in Hessian form: a*b + b*y + c*z + d = 0

Note: almost all methods on Plane require that the normal vector have unit length and will panic if this invariant is violated. This is not separately annotated for each method.

Fields

normal: Vector3

Normal vector, perpendicular to the plane.

Most Plane methods expect this vector to be normalized and may panic if this is not the case.

d: f32

Distance from the coordinate system origin (in the direction of normal).

This value is typically non-negative. It can however be negative, which behaves as if normal changed direction.

Implementations

impl Plane

pub fn new(normal: Vector3, d: f32) -> Plane

Creates a new Plane from the normal and the distance from the origin d.

Panics

In contrast to construction via Plane { normal, d }, this verifies that normal has unit length, and will panic if this is not the case.

pub fn from_coordinates(a: f32, b: f32, c: f32, d: f32) -> Plane

Creates a new Plane from normal and origin distance.

a, b, c are used for the normal vector. d is the distance from the origin.

Panics

See Self::new().

pub fn from_points(a: Vector3, b: Vector3, c: Vector3) -> Option<Plane>

Creates a new Plane from three Vector3, given in clockwise order.

If all three points are collinear, returns None.

pub fn center(self) -> Vector3

Returns the point on the Plane, which is closest to the origin.

This is equivalent to self.project(Vector3::ZERO).

pub fn project(self, point: Vector3) -> Vector3

Returns the orthogonal projection of point onto a point in the Plane.

The projection is a point, which lies on the plane and is closest to point.

pub fn distance_to(self, point: Vector3) -> f32

Returns the signed distance from the Plane to point.

This value is negative, if self.is_point_over(point) is false.

pub fn contains_point(self, point: Vector3) -> bool

Returns true if point is inside the Plane.

Uses a default epsilon for the boundary check. Use Self::contains_point_eps() for more control.

pub fn contains_point_eps(self, point: Vector3, epsilon: f32) -> bool

Returns true if point is inside the Plane.

epsilon specifies the minimum distance, at and below which a point is considered inside the Plane.

pub fn intersect_3(self, b: Plane, c: Plane) -> Option<Vector3>

Returns the intersection point of the three planes self, b and c.

Returns None if the planes don’t intersect.

pub fn intersect_ray(self, from: Vector3, dir: Vector3) -> Option<Vector3>

Returns the intersection point of a ray consisting of the position from and the direction vector dir with this plane.

Returns None if the ray doesn’t intersect.

pub fn intersect_segment(self, begin: Vector3, end: Vector3) -> Option<Vector3>

Returns the intersection point of a segment from begin to end with this Plane.

Returns None if the the segment doesn’t intersect.

pub fn is_equal_approx(self, other: Plane) -> bool

Returns true if this Plane and other are approximately equal.

pub fn is_point_over(self, point: Vector3) -> bool

Returns true if point is on the side of the Plane, into which normal points.

Points that lie exactly on the plane will be returned as false.

pub fn normalized(self) -> Plane

Returns the Plane normalized.

Panics

If self.normal is a zero vector. All other vectors are explicitly allowed.

Trait Implementations

impl Clone for Plane

fn clone(&self) -> Plane

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CoerceFromVariant for Plane

fn coerce_from_variant(v: &Variant) -> Plane

impl Debug for Plane

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Plane

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Plane, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Export for Plane

type Hint = NoHint

A type-specific hint type that is valid for the type being exported.

fn export_info(_hint: Option<<Plane as Export>::Hint>) -> ExportInfo

Returns ExportInfo given an optional typed hint.

impl FromVariant for Plane

fn from_variant(variant: &Variant) -> Result<Plane, FromVariantError>

impl PartialEq<Plane> for Plane

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Plane

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

Serialize this value into the given Serde serializer.

impl ToVariant for Plane

fn to_variant(&self) -> Variant

impl Copy for Plane

impl StructuralPartialEq for Plane