Enum Shape2d 

pub enum Shape2d {
    Point(Vec2),
    Line {
        start: Vec2,
        end: Vec2,
        pixel_count: usize,
    },
    Grid {
        start: Vec2,
        horizontal_end: Vec2,
        vertical_end: Vec2,
        horizontal_pixel_count: usize,
        vertical_pixel_count: usize,
        serpentine: bool,
    },
    Arc {
        center: Vec2,
        axis_u: Vec2,
        axis_v: Vec2,
        start_angle_in_radians: f32,
        end_angle_in_radians: f32,
        pixel_count: usize,
    },
}

Enumeration of two-dimensional shape primitives.

Each variant represents a different type of 2D arrangement of LEDs.

Variants

Point(Vec2)

A single point at the specified location.

Line

A line of LEDs from start to end with pixel_count LEDs.

Fields

start: Vec2

Starting point of the line

end: Vec2

Ending point of the line

pixel_count: usize

Number of LEDs along the line

Grid

A grid of LEDs defined by three corners and dimensions.

Fields

start: Vec2

Starting point (origin) of the grid

horizontal_end: Vec2

Ending point for first horizontal row (defines the horizontal axis)

vertical_end: Vec2

Ending point for first vertical column (defines the vertical axis)

horizontal_pixel_count: usize

Number of LEDs along each horizontal row

vertical_pixel_count: usize

Number of LEDs along each vertical column

serpentine: bool

Whether horizontal rows of LEDs are wired in a zigzag pattern

Arc

A circular or elliptical arc in 2D.

Parametric form:

point(theta) = center + cos(theta) * axis_u + sin(theta) * axis_v

Angle and direction:

• Theta = 0 lies along axis_u (i.e. center + axis_u)
  • As theta increases, the point moves towards axis_v (counter-clockwise in the XY plane).
• The arc is traced for theta in [start_angle_in_radians, end_angle_in_radians].
  • If end < start, the arc goes clockwise.
• Positive angles are counter-clockwise.
• To make a full ellipse, set end = start + TAU.

How to choose axis_u / axis_v:

• Axis-aligned circle with with radius r:
  • axis_u = (r, 0)
  • axis_v = (0, r)
• Axis-aligned ellipse with radii (rx, ry):
  • axis_u = (rx, 0)
  • axis_v = (0, ry)
• Rotated by phi:
  • axis_u = ( rx * cos(phi), rx * sin(phi))
  • axis_v = ( -ry * sin(phi), ry * cos(phi))

Notes:

• axis_u and axis_v must not both be zero.
• axis_u and axis_v need not be unit length of perpendicular.
• The points returned by shape::points() of a Shape2d::Arc:
  • Will have uniform density if a circular arc
  • Will not have uniform density if an elliptical arc, as the points correspond to theta.

Fields

center: Vec2

Center of the ellipse

axis_u: Vec2

Cosine-axis vector

axis_v: Vec2

Sine-axis vector

start_angle_in_radians: f32

Start angle in radians

end_angle_in_radians: f32

End angle in radians

pixel_count: usize

Number of LEDs

Implementations

impl Shape2d

pub const fn pixel_count(&self) -> usize

Returns the total number of pixels (LEDs) in this shape.

pub fn points(&self) -> Shape2dPointsIterator

Returns an iterator over all points (LED positions) in this shape.

Trait Implementations

impl Clone for Shape2d

fn clone(&self) -> Shape2d

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Shape2d

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

Formats the value using the given formatter.