Struct Segment3

pub struct Segment3<S> { /* private fields */ }

A 1-simplex or line segment in 3D space.

Creation methods should fail with a debug assertion if the points are identical.

Implementations

impl<S> Segment<S>

where S: Ring,

pub fn new(a: Point3<S>, b: Point3<S>) -> Segment<S>

where S: Debug,

Panics if the points are identical:

let s = Segment::new ([0.0, 0.0, 1.0].into(), [0.0, 0.0, 1.0].into());

pub fn unchecked(a: Point3<S>, b: Point3<S>) -> Segment<S>

where S: Debug,

Debug panic if the points are identical:

let s = Segment::unchecked ([0.0, 0.0, 1.0].into(), [0.0, 0.0, 1.0].into());

pub fn numcast<T>(self) -> Option<Segment<T>>

where S: NumCast, T: NumCast,

pub fn point_a(&self) -> &Point3<S>

pub fn point_b(&self) -> &Point3<S>

pub fn length(&self) -> S

where S: Field + Sqrt,

pub fn length2(&self) -> S

pub fn vector(&self) -> Vec3<S>

Returns point_b() - point_a()

pub fn aabb3(&self) -> Aabb3<S>

where S: Debug,

pub fn line3(&self) -> Line3<S>

where S: Real,

pub fn intersect_aabb( &self, aabb: &Aabb3<S>, ) -> Option<((S, Point3<S>), (S, Point3<S>))>

where S: Real + Float + RelativeEq<Epsilon = S> + Debug,

pub fn intersect_sphere( &self, sphere: &Sphere3<S>, ) -> Option<((S, Point3<S>), (S, Point3<S>))>

where S: Field + Sqrt,

pub fn intersect_cylinder( &self, sphere: &Cylinder3<S>, ) -> Option<((S, Point3<S>), (S, Point3<S>))>

where S: Real + Debug,

pub fn intersect_capsule( &self, capsule: &Capsule3<S>, ) -> Option<((S, Point3<S>), (S, Point3<S>))>

where S: Real + Debug,

Trait Implementations

impl<S> Clone for Segment<S>

where S: Clone,

fn clone(&self) -> Segment<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Segment<S>

where S: Debug,

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

Formats the value using the given formatter.

impl<S> Default for Segment<S>

where S: Field,

fn default() -> Segment<S>

A default simplex is arbitrarily chosen to be the simplex from -1.0 to 1.0 lying on the X axis:

assert_eq!(
  Segment::default(),
  Segment::new ([-1.0, 0.0, 0.0].into(), [1.0, 0.0, 0.0].into())
);

impl<'de, S> Deserialize<'de> for Segment<S>

where S: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> PartialEq for Segment<S>

where S: PartialEq,

fn eq(&self, other: &Segment<S>) -> 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<S> Serialize for Segment<S>

where S: Serialize,

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<S> Copy for Segment<S>

where S: Copy,

impl<S> StructuralPartialEq for Segment<S>