Struct ark_api::Plane3

pub struct Plane3 {
    pub normal: Vec3,
    pub d: f32,
}

A 3-dimensional plane primitive.

Represented by a normal and the signed distance from the origin to the plane.

This representation can specify any possible plane in 3D space using 4 parameters (disregarding floating point precision). There are duplicate representations caused by negating both parameters, but that’s fine - you could view it as an oriented plane.

A point point is on the plane when plane.normal.dot(point) + plane.d = 0.

Fields

normal: Vec3

Normal vector

d: f32

Distance

Implementations

impl Plane3

pub const YZ: Plane3 = Self{ normal: Vec3::X, d: 0.0,}

The Y^Z plane with normal = +X

pub const ZX: Plane3 = Self{ normal: Vec3::Y, d: 0.0,}

The Z^X plane with normal = +Y

pub const XY: Plane3 = Self{ normal: Vec3::Z, d: 0.0,}

The X^Y plane with normal = +Z

pub fn from_normal_dist(normal: Vec3, d: f32) -> Plane3

From the plane normal and a distance d so that for all points on the plane: normal.dot(point) + d = 0.

pub fn from_normal_point(normal: Vec3, point: Vec3) -> Plane3

From the plane normal and a point on the plane.

pub fn normalized(&self) -> Plane3

Get normalized plane

pub fn distance(&self, p: Vec3) -> f32

Computes the distance between the plane and the point p. The returned distance is only correct if the plane is normalized or the distance is zero.

pub fn intersect_ray(&self, origin: Vec3, dir: Vec3) -> (bool, f32)

The bool is whether the plane was hit or not.

If false, the ray was either perpendicular to the plane, or the ray shot away from the plane.

The returned f32 is the t value so you can easily compute the intersection point through “origin + dir * t”.

pub fn is_finite(&self) -> bool

True if every value is finite

pub fn as_vec4(&self) -> Vec4

The distance to a point [x, y, z, 1] is the dot product of the point and this.

Trait Implementations

impl Clone for Plane3

fn clone(&self) -> Plane3

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Plane3

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Plane3

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<Plane3> for Plane3

fn eq(&self, other: &Plane3) -> 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<'a_, C_> Readable<'a_, C_> for Plane3 where
    C_: Context, 

fn read_from<R_>(_reader_: &mut R_) -> Result<Plane3, <C_ as Context>::Error> where
    R_: Reader<'a_, C_>, 

fn minimum_bytes_needed() -> usize

fn read_from_buffer_with_ctx(
    context: C,
    buffer: &'a [u8]
) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_with_ctx(
    context: C,
    buffer: &'a [u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_buffer_copying_data_with_ctx(
    context: C,
    buffer: &[u8]
) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_copying_data_with_ctx(
    context: C,
    buffer: &[u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_with_length_from_buffer_copying_data_with_ctx_mut(
    context: &mut C,
    buffer: &[u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_stream_unbuffered_with_ctx<S>(
    context: C,
    stream: S
) -> Result<Self, <C as Context>::Error> where
    S: Read, 

fn read_from_stream_buffered_with_ctx<S>(
    context: C,
    stream: S
) -> Result<Self, <C as Context>::Error> where
    S: Read, 

fn read_from_file_with_ctx(
    context: C,
    path: impl AsRef<Path>
) -> Result<Self, <C as Context>::Error>

impl Serialize for Plane3

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<C_> Writable<C_> for Plane3 where
    C_: Context, 

fn write_to<T_>(&self, _writer_: &mut T_) -> Result<(), <C_ as Context>::Error> where
    T_: Writer<C_> + ?Sized, 

fn write_to_buffer_with_ctx(
    &self,
    context: C,
    buffer: &mut [u8]
) -> Result<(), <C as Context>::Error>

fn write_to_buffer_with_ctx_mut(
    &self,
    context: &mut C,
    buffer: &mut [u8]
) -> Result<(), <C as Context>::Error>

fn write_to_vec_with_ctx(
    &self,
    context: C
) -> Result<Vec<u8, Global>, <C as Context>::Error>

fn write_to_vec_with_ctx_mut(
    &self,
    context: &mut C
) -> Result<Vec<u8, Global>, <C as Context>::Error>

fn write_to_stream_with_ctx<S>(
    &self,
    context: C,
    stream: S
) -> Result<(), <C as Context>::Error> where
    S: Write, 

fn write_to_file_with_ctx(
    &self,
    context: C,
    path: impl AsRef<Path>
) -> Result<(), <C as Context>::Error>

fn bytes_needed(&self) -> Result<usize, <C as Context>::Error>

impl Copy for Plane3

impl StructuralPartialEq for Plane3