Struct QuadraticBezier2

pub struct QuadraticBezier2<T> {
    pub start: Vec2<T>,
    pub ctrl: Vec2<T>,
    pub end: Vec2<T>,
}

A 2D Bézier curve with one control point.

2x2 and 3x3 matrices can be multiplied by a Bézier curve to transform all of its points.

Also note that quadratic Bézier curves are quite bad at approximating circles. See the relevant section of “A Primer on Bézier Curves” for an explanation.

Fields

start: Vec2<T>

Starting point of the curve.

ctrl: Vec2<T>

Control point of the curve.

end: Vec2<T>

End point of the curve.

Implementations

impl<T> QuadraticBezier2<T>

where T: Real,

pub fn evaluate(self, t: T) -> Vec2<T>

Evaluates the position of the point lying on the curve at interpolation factor t.

This is one of the most important Bézier curve operations, because, in one way or another, it is used to render a curve to the screen. The common use case is to successively evaluate a curve at a set of values that range from 0 to 1, to approximate the curve as an array of line segments which are then rendered.

pub fn evaluate_derivative(self, t: T) -> Vec2<T>

Evaluates the derivative tangent at interpolation factor t, which happens to give a non-normalized tangent vector.

See also normalized_tangent().

pub fn matrix() -> Mat3<T>

Returns the constant matrix M such that, given T = [1, t*t, t*t*t] and P the vector of control points, dot(T * M, P) evalutes the Bezier curve at ‘t’.

This function name is arguably dubious.

pub fn split(self, t: T) -> [QuadraticBezier2<T>; 2]

Splits this quadratic Bézier curve into two curves, at interpolation factor t.

pub fn into_cubic(self) -> CubicBezier2<T>

Elevates this curve into a cubic Bézier curve.

impl<T> QuadraticBezier2<T>

pub fn reversed(self) -> QuadraticBezier2<T>

Gets this curve reversed, i.e swaps start with end.

pub fn reverse(&mut self)

Reverses this curve, i.e swaps start with end.

pub fn into_vec3(self) -> Vec3<Vec2<T>>

Converts this curve into a Vec3 of points.

pub fn into_tuple(self) -> (Vec2<T>, Vec2<T>, Vec2<T>)

Converts this curve into a tuple of points.

pub fn into_array(self) -> [Vec2<T>; 3]

Converts this curve into an array of points.

impl<T> QuadraticBezier2<T>

where T: Real,

pub fn x_inflection(self) -> Option<T>

Returns the evaluation factor that gives an inflection point along the X axis, if any.

pub fn min_x(self) -> T

Returns the evaluation factor that gives the point on the curve which X coordinate is the minimum.

pub fn max_x(self) -> T

Returns the evaluation factor that gives the point on the curve which X coordinate is the maximum.

pub fn x_bounds(self) -> (T, T)

Returns the evaluation factors that give the points on the curve which X coordinates are the respective minimum and maximum.

impl<T> QuadraticBezier2<T>

where T: Real,

pub fn y_inflection(self) -> Option<T>

Returns the evaluation factor that gives an inflection point along the Y axis, if any.

pub fn min_y(self) -> T

Returns the evaluation factor that gives the point on the curve which Y coordinate is the minimum.

pub fn max_y(self) -> T

Returns the evaluation factor that gives the point on the curve which Y coordinate is the maximum.

pub fn y_bounds(self) -> (T, T)

Returns the evaluation factors that give the points on the curve which Y coordinates are the respective minimum and maximum.

impl<T> QuadraticBezier2<T>

where T: Real,

pub fn normalized_tangent(self, t: T) -> Vec2<T>

where T: Add<Output = T>,

Evaluates the normalized tangent at interpolation factor t.

pub fn length_by_discretization(self, step_count: u16) -> T

where T: Add<Output = T> + From<u16>,

Approximates the curve’s length by subdividing it into step_count+1 segments.

pub fn aabr(self) -> Aabr<T>

Gets the Axis-Aligned Bounding Rectangle for this curve.

On 3D curves, this discards the z values.

pub fn flipped_x(self) -> QuadraticBezier2<T>

Returns this curve, flipping the x coordinate of each of its points.

pub fn flipped_y(self) -> QuadraticBezier2<T>

Returns this curve, flipping the y coordinate of each of its points.

pub fn flip_x(&mut self)

Flips the x coordinate of all points of this curve.

pub fn flip_y(&mut self)

Flips the y coordinate of all points of this curve.

pub fn binary_search_point_by_steps( self, p: Vec2<T>, steps: u16, epsilon: T, ) -> (T, Vec2<T>)

where T: Add<Output = T> + From<u16>,

Searches for the point lying on this curve that is closest to p.

steps is the number of points to sample in the curve for the “broad phase” that takes place before the binary search.

epsilon denotes the desired precision for the result. The higher it is, the sooner the algorithm will finish, but the result would be less satisfactory.

Panics

Panics if epsilon is less than or equal to T::epsilon().
epsilon must be positive and not approximately equal to zero.

pub fn binary_search_point<I>( self, p: Vec2<T>, coarse: I, half_interval: T, epsilon: T, ) -> (T, Vec2<T>)

where T: Add<Output = T>, I: IntoIterator<Item = (T, Vec2<T>)>,

Searches for the point lying on this curve that is closest to p.

For an example usage, see the source code of binary_search_point_by_steps().

coarse is an iterator over pairs of (interpolation_value, point) that are assumed to, together, represent a discretization of the curve.
This parameter is used for a “broad phase” - the point yielded by coarse that is closest to p is the starting point for the binary search.
coarse may very well yield a single pair; Also, it was designed so that, if you already have the values handy, there is no need to recompute them.
This function doesn’t panic if coarse yields no element, but then it would be very unlikely for the result to be satisfactory.

half_interval is the starting value for the half of the binary search interval.

epsilon denotes the desired precision for the result. The higher it is, the sooner the algorithm will finish, but the result would be less satisfactory.

Panics

Panics if epsilon is less than or equal to T::epsilon().
epsilon must be positive and not approximately equal to zero.

impl<T> QuadraticBezier2<T>

where T: Zero,

pub fn into_3d(self) -> QuadraticBezier3<T>

Converts this 2D curve to a 3D one, setting the z elements to zero.

Trait Implementations

impl<T> Clone for QuadraticBezier2<T>

where T: Clone,

fn clone(&self) -> QuadraticBezier2<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for QuadraticBezier2<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for QuadraticBezier2<T>

where T: Default,

fn default() -> QuadraticBezier2<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for QuadraticBezier2<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<LineSegment2<T>> for QuadraticBezier2<T>

where T: Real,

fn from(line_segment: LineSegment2<T>) -> QuadraticBezier2<T>

Converts to this type from the input type.

impl<T> From<QuadraticBezier2<T>> for CubicBezier2<T>

where T: Real,

fn from(b: QuadraticBezier2<T>) -> CubicBezier2<T>

Converts to this type from the input type.

impl<T> From<QuadraticBezier2<T>> for QuadraticBezier3<T>

where T: Zero,

fn from(c: QuadraticBezier2<T>) -> QuadraticBezier3<T>

Converts to this type from the input type.

impl<T> From<QuadraticBezier2<T>> for Vec3<Vec2<T>>

fn from(v: QuadraticBezier2<T>) -> Vec3<Vec2<T>>

Converts to this type from the input type.

impl<T> From<QuadraticBezier3<T>> for QuadraticBezier2<T>

fn from(c: QuadraticBezier3<T>) -> QuadraticBezier2<T>

Converts to this type from the input type.

impl<T> From<Range<Vec2<T>>> for QuadraticBezier2<T>

where T: Real,

fn from(range: Range<Vec2<T>>) -> QuadraticBezier2<T>

Converts to this type from the input type.

impl<T> From<Vec3<Vec2<T>>> for QuadraticBezier2<T>

fn from(v: Vec3<Vec2<T>>) -> QuadraticBezier2<T>

Converts to this type from the input type.

impl<T> Hash for QuadraticBezier2<T>

where T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for QuadraticBezier2<T>

where T: PartialEq,

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

where T: 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<T> Copy for QuadraticBezier2<T>

where T: Copy,

impl<T> Eq for QuadraticBezier2<T>

where T: Eq,

impl<T> StructuralPartialEq for QuadraticBezier2<T>