Struct Vec2 

pub struct Vec2 {
    pub x: f64,
    pub y: f64,
}

A 2D vector.

This is intended primarily for a vector in the mathematical sense, but it can be interpreted as a translation, and converted to and from a Point (vector relative to the origin) and Size.

Fields

x: f64

The x-coordinate.

y: f64

The y-coordinate.

Implementations

impl Vec2

pub const ZERO: Vec2

The vector (0, 0).

pub const fn new(x: f64, y: f64) -> Vec2

Create a new vector.

Examples found in repository

examples/shapes_demo.rs (line 72)

fn draw_shape_attached(
    scene: &mut impl SceneBuilder,
    shape: &Shape,
    placement: Point,
    direction: Vec2,
    size: f64,
    brush: &Brush,
    stroke_world_width: f64,
) {
    let perp = Vec2::new(-direction.y, direction.x);
    let a = shape.anchor();
    let anchor_world = direction * (a.x * size) + perp * (a.y * size);
    let origin = placement - anchor_world;
    let xform = Affine::translate(origin.to_vec2())
        * Affine::rotate(direction.atan2())
        * Affine::scale(size);
    let (paths, style) = match shape.kind() {
        ShapeKind::Paths { paths, style } => (paths, style),
        ShapeKind::Glyph { .. } => return,
    };
    match style {
        ShapeStyle::Fill => {
            for sub in paths {
                scene.fill(FillRule::NonZero, xform, brush, None, sub, PickId::Skip);
            }
        }
        ShapeStyle::Stroke => {
            let stroke = Stroke::new(stroke_world_width / size)
                .with_caps(Cap::Round)
                .with_join(Join::Round);
            for sub in paths {
                scene.stroke(&stroke, xform, brush, None, sub, PickId::Skip);
            }
        }
    }
}

pub const fn to_point(self) -> Point

Convert this vector into a Point.

pub const fn to_size(self) -> Size

Convert this vector into a Size.

pub const fn splat(v: f64) -> Vec2

Create a vector with the same value for x and y.

pub const fn dot(self, other: Vec2) -> f64

Dot product of two vectors.

pub const fn cross(self, other: Vec2) -> f64

Cross product of two vectors.

This is signed so that (1, 0) × (0, 1) = 1.

The following relations hold:

u.cross(v) = -v.cross(u)

v.cross(v) = 0.0

pub fn hypot(self) -> f64

Magnitude of vector.

See Point::distance for the same operation on Point.

Examples

use kurbo::Vec2;
let v = Vec2::new(3.0, 4.0);
assert_eq!(v.hypot(), 5.0);

pub fn length(self) -> f64

Magnitude of vector.

This is an alias for Vec2::hypot.

pub const fn hypot2(self) -> f64

Magnitude squared of vector.

See Point::distance_squared for the same operation on Point.

Examples

use kurbo::Vec2;
let v = Vec2::new(3.0, 4.0);
assert_eq!(v.hypot2(), 25.0);

pub const fn length_squared(self) -> f64

Magnitude squared of vector.

This is an alias for Vec2::hypot2.

pub fn atan2(self) -> f64

Find the angle in radians between this vector and the vector Vec2 { x: 1.0, y: 0.0 } in the positive y direction.

If the vector is interpreted as a complex number, this is the argument. The angle is expressed in radians.

Examples found in repository

examples/shapes_demo.rs (line 77)

fn draw_shape_attached(
    scene: &mut impl SceneBuilder,
    shape: &Shape,
    placement: Point,
    direction: Vec2,
    size: f64,
    brush: &Brush,
    stroke_world_width: f64,
) {
    let perp = Vec2::new(-direction.y, direction.x);
    let a = shape.anchor();
    let anchor_world = direction * (a.x * size) + perp * (a.y * size);
    let origin = placement - anchor_world;
    let xform = Affine::translate(origin.to_vec2())
        * Affine::rotate(direction.atan2())
        * Affine::scale(size);
    let (paths, style) = match shape.kind() {
        ShapeKind::Paths { paths, style } => (paths, style),
        ShapeKind::Glyph { .. } => return,
    };
    match style {
        ShapeStyle::Fill => {
            for sub in paths {
                scene.fill(FillRule::NonZero, xform, brush, None, sub, PickId::Skip);
            }
        }
        ShapeStyle::Stroke => {
            let stroke = Stroke::new(stroke_world_width / size)
                .with_caps(Cap::Round)
                .with_join(Join::Round);
            for sub in paths {
                scene.stroke(&stroke, xform, brush, None, sub, PickId::Skip);
            }
        }
    }
}

pub fn angle(self) -> f64

Find the angle in radians between this vector and the vector Vec2 { x: 1.0, y: 0.0 } in the positive y direction.

This is an alias for Vec2::atan2.

pub fn from_angle(th: f64) -> Vec2

A unit vector of the given angle.

With th at zero, the result is the positive X unit vector, and at π/2, it is the positive Y unit vector. The angle is expressed in radians.

Thus, in a Y-down coordinate system (as is common for graphics), it is a clockwise rotation, and in Y-up (traditional for math), it is anti-clockwise. This convention is consistent with Affine::rotate.

pub fn lerp(self, other: Vec2, t: f64) -> Vec2

Linearly interpolate between two vectors.

pub fn normalize(self) -> Vec2

Returns a vector of magnitude 1.0 with the same angle as self; i.e. a unit/direction vector.

This produces NaN values when the magnitude is 0.

Examples found in repository

examples/shapes_demo.rs (line 154)

fn main() {
    let mut renderer = VelloRenderer::new().expect("vello renderer init");
    let registry = ShapeRegistry::with_builtins();

    let glyph_brush: Brush = rgb8(60, 130, 220).into();
    let chrome_brush: Brush = rgb8(80, 84, 96).into();
    let line_brush: Brush = rgb8(190, 195, 205).into();

    let glyph_world_stroke = 2.0;
    let line_stroke = Stroke::new(2.5).with_caps(Cap::Butt);
    let cell_stroke = Stroke::new(1.0);

    {
        let scene = renderer.scene();

        for (i, name) in builtin::NAMES.iter().enumerate() {
            let center = cell_center(i);
            let cell = Rect::new(
                center.x - CELL_W * 0.5 + 2.0,
                center.y - CELL_H * 0.5 + 2.0,
                center.x + CELL_W * 0.5 - 2.0,
                center.y + CELL_H * 0.5 - 2.0,
            )
            .to_path(0.1);
            scene.stroke(
                &cell_stroke,
                Affine::IDENTITY,
                &chrome_brush,
                None,
                &cell,
                PickId::Skip,
            );

            let shape = registry.get(name).expect("registered");
            draw_shape_centered(scene, shape, center, 28.0, &glyph_brush, glyph_world_stroke);
        }

        let demos: &[(&str, f64)] = &[
            ("arrow-closed", 18.0),
            ("arrow-stealth", 22.0),
            ("arrow-open", 18.0),
            ("arrow-feather", 28.0),
            ("arrow-dot", 14.0),
        ];
        let demo_top = GRID_TOP + (GRID_ROWS as f64) * CELL_H + 25.0;
        let demo_spacing = 28.0;
        let x_start = 60.0;
        let x_end = (W as f64) - 60.0;

        for (i, &(name, size)) in demos.iter().enumerate() {
            let y = demo_top + (i as f64) * demo_spacing;
            let start = Point::new(x_start, y);
            let end = Point::new(x_end, y);

            let direction = (end - start).normalize();
            let shape = registry.get(name).expect("registered");

            let mut line = hephaestus::Path::new();
            line.move_to(start);
            line.line_to(end);
            scene.stroke(
                &line_stroke,
                Affine::IDENTITY,
                &line_brush,
                None,
                &line,
                PickId::Skip,
            );

            draw_shape_attached(
                scene,
                shape,
                end,
                direction,
                size,
                &glyph_brush,
                glyph_world_stroke,
            );
        }
    }

    let mut pixels = vec![0u8; (W * H * 4) as usize];
    let bg: Color = rgb8(20, 22, 28);
    renderer
        .render_to_buffer(W, H, bg, &mut pixels)
        .expect("render");

    let path = std::env::current_dir()
        .unwrap()
        .join("examples/shapes_demo.png");
    hephaestus::image::write_png(&path, W, H, &pixels).expect("write png");
    println!("wrote {}", path.display());
}

pub fn round(self) -> Vec2

Returns a new Vec2, with x and y rounded to the nearest integer.

Examples

use kurbo::Vec2;
let a = Vec2::new(3.3, 3.6).round();
let b = Vec2::new(3.0, -3.1).round();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);

pub fn ceil(self) -> Vec2

Returns a new Vec2, with x and y rounded up to the nearest integer, unless they are already an integer.

Examples

use kurbo::Vec2;
let a = Vec2::new(3.3, 3.6).ceil();
let b = Vec2::new(3.0, -3.1).ceil();
assert_eq!(a.x, 4.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);

pub fn floor(self) -> Vec2

Returns a new Vec2, with x and y rounded down to the nearest integer, unless they are already an integer.

Examples

use kurbo::Vec2;
let a = Vec2::new(3.3, 3.6).floor();
let b = Vec2::new(3.0, -3.1).floor();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 3.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -4.0);

pub fn expand(self) -> Vec2

Returns a new Vec2, with x and y rounded away from zero to the nearest integer, unless they are already an integer.

Examples

use kurbo::Vec2;
let a = Vec2::new(3.3, 3.6).expand();
let b = Vec2::new(3.0, -3.1).expand();
assert_eq!(a.x, 4.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -4.0);

pub fn trunc(self) -> Vec2

Returns a new Vec2, with x and y rounded towards zero to the nearest integer, unless they are already an integer.

Examples

use kurbo::Vec2;
let a = Vec2::new(3.3, 3.6).trunc();
let b = Vec2::new(3.0, -3.1).trunc();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 3.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);

pub const fn is_finite(self) -> bool

Is this Vec2 finite?

pub const fn is_nan(self) -> bool

Is this Vec2 NaN?

pub const fn turn_90(self) -> Vec2

Turn by 90 degrees.

The rotation is clockwise in a Y-down coordinate system. The following relations hold:

u.dot(v) = u.cross(v.turn_90())

u.cross(v) = u.turn_90().dot(v)

pub const fn rotate_scale(self, rhs: Vec2) -> Vec2

Combine two vectors interpreted as rotation and scaling.

Interpret both vectors as a rotation and a scale, and combine their effects. by adding the angles and multiplying the magnitudes. This operation is equivalent to multiplication when the vectors are interpreted as complex numbers. It is commutative.

pub const fn get_coord(self, axis: Axis) -> f64

Get the member matching the given axis.

pub const fn get_coord_mut(&mut self, axis: Axis) -> &mut f64

Get a mutable reference to the member matching the given axis.

pub const fn set_coord(&mut self, axis: Axis, value: f64)

Set the member matching the given axis to the given value.

Trait Implementations

impl Add for Vec2

type Output = Vec2

The resulting type after applying the + operator.

fn add(self, other: Vec2) -> Vec2

Performs the + operation.

impl Add<TranslateScale> for Vec2

type Output = TranslateScale

The resulting type after applying the + operator.

fn add(self, other: TranslateScale) -> TranslateScale

Performs the + operation.

impl Add<Vec2> for Circle

type Output = Circle

The resulting type after applying the + operator.

fn add(self, v: Vec2) -> Circle

Performs the + operation.

impl Add<Vec2> for Ellipse

fn add(self, v: Vec2) -> Ellipse

In this context adding a Vec2 applies the corresponding translation to the ellipse.

type Output = Ellipse

The resulting type after applying the + operator.

impl Add<Vec2> for Line

type Output = Line

The resulting type after applying the + operator.

fn add(self, v: Vec2) -> Line

Performs the + operation.

impl Add<Vec2> for Point

type Output = Point

The resulting type after applying the + operator.

fn add(self, other: Vec2) -> Point

Performs the + operation.

impl Add<Vec2> for Rect

type Output = Rect

The resulting type after applying the + operator.

fn add(self, v: Vec2) -> Rect

Performs the + operation.

impl Add<Vec2> for RoundedRect

type Output = RoundedRect

The resulting type after applying the + operator.

fn add(self, v: Vec2) -> RoundedRect

Performs the + operation.

impl AddAssign for Vec2

fn add_assign(&mut self, other: Vec2)

Performs the += operation.

impl AddAssign<Vec2> for Point

fn add_assign(&mut self, other: Vec2)

Performs the += operation.

impl Clone for Vec2

fn clone(&self) -> Vec2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Vec2

impl Debug for Vec2

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

Formats the value using the given formatter.

impl Default for Vec2

fn default() -> Vec2

Returns the “default value” for a type.

impl Display for Vec2

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

Formats the value using the given formatter.

impl Div<f64> for Vec2

fn div(self, other: f64) -> Vec2

Note: division by a scalar is implemented by multiplying by the reciprocal.

This is more efficient but has different roundoff behavior than division.

type Output = Vec2

The resulting type after applying the / operator.

impl DivAssign<f64> for Vec2

fn div_assign(&mut self, other: f64)

Performs the /= operation.

impl From<(f64, f64)> for Vec2

fn from(v: (f64, f64)) -> Vec2

Converts to this type from the input type.

impl Mul<f64> for Vec2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Vec2

Performs the * operation.

impl MulAssign<f64> for Vec2

fn mul_assign(&mut self, other: f64)

Performs the *= operation.

impl Neg for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn neg(self) -> Vec2

Performs the unary - operation.

impl PartialEq for Vec2

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Vec2

impl Sub for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn sub(self, other: Vec2) -> Vec2

Performs the - operation.

impl Sub<Vec2> for Circle

type Output = Circle

The resulting type after applying the - operator.

fn sub(self, v: Vec2) -> Circle

Performs the - operation.

impl Sub<Vec2> for Ellipse

fn sub(self, v: Vec2) -> Ellipse

In this context subtracting a Vec2 applies the corresponding translation to the ellipse.

type Output = Ellipse

The resulting type after applying the - operator.

impl Sub<Vec2> for Line

type Output = Line

The resulting type after applying the - operator.

fn sub(self, v: Vec2) -> Line

Performs the - operation.

impl Sub<Vec2> for Point

type Output = Point

The resulting type after applying the - operator.

fn sub(self, other: Vec2) -> Point

Performs the - operation.

impl Sub<Vec2> for Rect

type Output = Rect

The resulting type after applying the - operator.

fn sub(self, v: Vec2) -> Rect

Performs the - operation.

impl Sub<Vec2> for RoundedRect

type Output = RoundedRect

The resulting type after applying the - operator.

fn sub(self, v: Vec2) -> RoundedRect

Performs the - operation.

impl SubAssign for Vec2

fn sub_assign(&mut self, other: Vec2)

Performs the -= operation.

impl SubAssign<Vec2> for Point

fn sub_assign(&mut self, other: Vec2)

Performs the -= operation.

impl Sum for Vec2

fn sum<I>(iter: I) -> Vec2

where I: Iterator<Item = Vec2>,

Takes an iterator and generates Self from the elements by “summing up” the items.