Struct nannou::draw::primitive::path::PathOptions

pub struct PathOptions<T, S = Default> { /* fields omitted */ }

A path drawing context ready to specify tessellation options.

Methods

impl<T, S> PathOptions<T, S> where
    S: Zero, 

pub fn new(opts: T) -> Self

Initialise the PathOptions builder.

impl<S> PathOptions<FillOptions, S>

pub fn tolerance(self, tolerance: f32) -> Self

Maximum allowed distance to the path when building an approximation.

This method is shorthand for the fill_tolerance method.

pub fn rule(self, rule: FillRule) -> Self

Specify the rule used to determine what is inside and what is outside of the shape.

Currently, only the EvenOdd rule is implemented.

This method is shorthand for the fill_rule method.

impl<S> PathOptions<StrokeOptions, S>

pub fn weight(self, weight: f32) -> Self

Short-hand for the stroke_weight method.

pub fn tolerance(self, tolerance: f32) -> Self

Short-hand for the stroke_tolerance method.

impl<T, S> PathOptions<T, S> where
    T: TessellationOptions, 

pub fn points<I>(self, ctxt: DrawingContext<S>, points: I) -> Path<S> where
    S: BaseFloat,
    I: IntoIterator,
    I::Item: Into<Point2<S>>, 

Consumes an iterator of points and converts them to an iterator yielding path events.

pub fn points_closed<I>(self, ctxt: DrawingContext<S>, points: I) -> Path<S> where
    S: BaseFloat,
    I: IntoIterator,
    I::Item: Into<Point2<S>>, 

Consumes an iterator of points and converts them to an iterator yielding path events.

Closes the start and end points.

pub fn points_colored<I, P, C>(
    self,
    ctxt: DrawingContext<S>,
    points: I
) -> Path<S> where
    S: BaseFloat,
    I: IntoIterator<Item = (P, C)>,
    P: Into<Point2<S>>,
    C: IntoLinSrgba<ColorScalar>, 

Submit path events as a polyline of colored points.

pub fn points_colored_closed<I, P, C>(
    self,
    ctxt: DrawingContext<S>,
    points: I
) -> Path<S> where
    S: BaseFloat,
    I: IntoIterator<Item = (P, C)>,
    P: Into<Point2<S>>,
    C: IntoLinSrgba<ColorScalar>, 

Submit path events as a polyline of colored points.

pub fn points_textured<I, P, TC>(
    self,
    ctxt: DrawingContext<S>,
    texture_view: &dyn ToTextureView,
    points: I
) -> Path<S> where
    S: BaseFloat,
    I: IntoIterator<Item = (P, TC)>,
    P: Into<Point2<S>>,
    TC: Into<TexCoords<S>>, 

Submit path events as a polyline of textured points.

pub fn points_textured_closed<I, P, TC>(
    self,
    ctxt: DrawingContext<S>,
    texture_view: &dyn ToTextureView,
    points: I
) -> Path<S> where
    S: BaseFloat,
    I: IntoIterator<Item = (P, TC)>,
    P: Into<Point2<S>>,
    TC: Into<TexCoords<S>>, 

Submit path events as a polyline of textured points.

Trait Implementations

impl<T: Clone, S: Clone> Clone for PathOptions<T, S>

fn clone(&self) -> PathOptions<T, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, S: Debug> Debug for PathOptions<T, S>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, S> Default for PathOptions<T, S> where
    S: Zero,
    T: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<S> From<PathOptions<FillOptions, S>> for Primitive<S>

fn from(prim: PathFill<S>) -> Self

Performs the conversion.

impl<S> From<PathOptions<StrokeOptions, S>> for Primitive<S>

fn from(prim: PathStroke<S>) -> Self

Performs the conversion.

impl<T, S> SetColor<f32> for PathOptions<T, S>

fn rgba_mut(&mut self) -> &mut Option<LinSrgba>

Provide a mutable reference to the RGBA field which can be used for setting colors.

fn color<C>(self, color: C) -> Self where
    C: IntoLinSrgba<S>, 

Specify a color.

fn rgb<T>(self, r: T, g: T, b: T) -> Self where
    T: Component,
    S: Float, 

Specify the color via red, green and blue channels.

fn rgb8(self, r: u8, g: u8, b: u8) -> Self where
    S: Float, 

Specify the color via red, green and blue channels as bytes

fn rgba<T>(self, r: T, g: T, b: T, a: T) -> Self where
    T: Component,
    S: Float, 

Specify the color via red, green, blue and alpha channels.

fn rgba8(self, r: u8, g: u8, b: u8, a: u8) -> Self where
    S: Float, 

Specify the color via red, green, blue and alpha channels as bytes

fn hsl(self, h: S, s: S, l: S) -> Self where
    S: Float + Into<RgbHue<S>>, 

Specify the color via hue, saturation and luminance.

fn hsla(self, h: S, s: S, l: S, a: S) -> Self where
    S: Float + Into<RgbHue<S>>, 

Specify the color via hue, saturation, luminance and an alpha channel.

fn hsv(self, h: S, s: S, v: S) -> Self where
    S: Float, 

Specify the color via hue, saturation and value (brightness).

fn hsva(self, h: S, s: S, v: S, a: S) -> Self where
    S: Float, 

Specify the color via hue, saturation, value (brightness) and an alpha channel.

fn gray<T>(self, g: T) -> Self where
    T: Component,
    S: Float, 

Specify the color as gray scale

impl<T, S> SetOrientation<S> for PathOptions<T, S>

fn properties(&mut self) -> &mut Properties<S>

Provide a mutable reference to the orientation::Properties for updating.

fn look_at(self, target: Point3<S>) -> Self

Describe orientation via the vector that points to the given target.

fn x_radians(self, x: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the x axis as an absolute value in radians.

fn y_radians(self, y: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the y axis as an absolute value in radians.

fn z_radians(self, z: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the z axis as an absolute value in radians.

fn x_degrees(self, x: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the x axis as an absolute value in degrees.

fn y_degrees(self, y: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the y axis as an absolute value in degrees.

fn z_degrees(self, z: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the z axis as an absolute value in degrees.

fn x_turns(self, x: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the x axis as a number of turns around the axis.

fn y_turns(self, y: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the y axis as a number of turns around the axis.

fn z_turns(self, z: S) -> Self where
    S: BaseFloat, 

Specify the orientation around the z axis as a number of turns around the axis.

fn radians(self, v: Vector3<S>) -> Self where
    S: BaseFloat, 

Specify the orientation along each axis with the given Vector of radians.

fn degrees(self, v: Vector3<S>) -> Self where
    S: BaseFloat, 

Specify the orientation along each axis with the given Vector of degrees.

fn turns(self, v: Vector3<S>) -> Self where
    S: BaseFloat, 

Specify the orientation along each axis with the given Vector of "turns".

fn euler<A>(self, e: Euler<A>) -> Self where
    S: BaseFloat,
    A: Angle + Into<Rad<S>>, 

Specify the orientation with the given Euler.

fn quaternion(self, q: Quaternion<S>) -> Self where
    S: BaseFloat, 

Specify the orientation with the given Quaternion.

fn pitch(self, pitch: S) -> Self where
    S: BaseFloat, 

Specify the "pitch" of the orientation in radians.

fn yaw(self, yaw: S) -> Self where
    S: BaseFloat, 

Specify the "yaw" of the orientation in radians.

fn roll(self, roll: S) -> Self where
    S: BaseFloat, 

Specify the "roll" of the orientation in radians.

fn rotate(self, radians: S) -> Self where
    S: BaseFloat, 

Assuming we're looking at a 2D plane, positive values cause a clockwise rotation where the given value is specified in radians.

impl<T, S> SetPosition<S> for PathOptions<T, S>

fn properties(&mut self) -> &mut Properties<S>

Provide a mutable reference to the position::Properties for updating.

fn x(self, x: S) -> Self

Build with the given Absolute Position along the x axis.

fn y(self, y: S) -> Self

Build with the given Absolute Position along the y axis.

fn z(self, z: S) -> Self

Build with the given Absolute Position along the z axis.

fn xy(self, p: Point2<S>) -> Self

Set the Position with some two-dimensional point.

fn xyz(self, p: Point3<S>) -> Self

Set the Position with some three-dimensional point.

fn x_y(self, x: S, y: S) -> Self

Set the Position with x y coordinates.

fn x_y_z(self, x: S, y: S, z: S) -> Self

Set the Position with x y z coordinates.