Struct Ellipse

pub struct Ellipse<'a, C: 'a> { /* private fields */ }

An ellipse that can be drawn to the screen.

Implementations

impl<'a, C> Ellipse<'a, C>

pub fn segments(&mut self, segments: u16) -> &mut Self

Sets the number of segments that are used to approximate a circle.

Example

use lux::prelude::*;
use lux::graphics::ColorVertex;

let mut window = Window::new().unwrap();
let mut frame = window.frame();
let (x, y, size) = (10.0, 10.0, 50.0);
// draw a pentagon
frame.circle(x, y, size).segments(5).draw();

pub fn line_length(&mut self, line_length: u16) -> &mut Self

Instead of

impl<'a, C> Ellipse<'a, C>

where C: Canvas + 'a,

pub fn fill(&mut self)

Fills in the ellipse with a solid color.

Trait Implementations

impl<'a, C> Colored for Ellipse<'a, C>

fn get_color(&self) -> [Float; 4]

Returns the current color.

fn color<A: Color>(&mut self, color: A) -> &mut Self

Sets the color.

fn with_color<F, R, C: Color>(&mut self, color: C, f: F)

where F: FnOnce(&mut Self) -> R,

Executes a closure with the given color, then resets it to what it was before.

impl<'a, C> Transform for Ellipse<'a, C>

fn current_matrix(&self) -> &[[Float; 4]; 4]

Return a reference to the current matrix.

fn current_matrix_mut(&mut self) -> &mut [[Float; 4]; 4]

Return a mutible reference to the current matrix.

fn apply_matrix(&mut self, other: [[Float; 4]; 4]) -> &mut Self

Multiplies the current matrix against another. self = self * other.

fn translate(&mut self, dx: Float, dy: Float) -> &mut Self

Applies a translation transformation to the matrix.

fn scale(&mut self, sx: Float, sy: Float) -> &mut Self

Applies a scaling transformation to the matrix.

fn shear(&mut self, sx: Float, sy: Float) -> &mut Self

Applies a shearing transformation to the matrix.

fn rotate(&mut self, theta: Float) -> &mut Self

Applies a rotation transformation to the matrix.

fn rotate_around(&mut self, point: (Float, Float), theta: Float) -> &mut Self

Combines rotation with translation to effectively rotate around a given point.

fn with_matrix<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut Self) -> R,

Used when you want to make several successive calls to transformations on a single stacked matrix.

fn with_rotation<F, R>(&mut self, rotation: Float, f: F) -> R

where F: FnOnce(&mut Self) -> R,

Similar to with_matrix but with a rotation applied for the duration of the closure.

fn with_translate<F, R>(&mut self, dx: Float, dy: Float, f: F) -> R

where F: FnOnce(&mut Self) -> R,

Similar to with_matrix but with a translation applied for the duration of the closure.

fn with_scale<F, R>(&mut self, scale_x: Float, scale_y: Float, f: F) -> R

where F: FnOnce(&mut Self) -> R,

Similar to with_matrix but with a scale applied for the duration of the closure.

fn with_shear<F, R>(&mut self, sx: Float, sy: Float, f: F) -> R

where F: FnOnce(&mut Self) -> R,

Similar to with_matrix but with a shear applied for the duration of the closure.

fn with_rotate_around<F, R>( &mut self, point: (Float, Float), theta: Float, f: F, ) -> R

where F: FnOnce(&mut Self) -> R,

Similar to with_matrix but with rotate_around applied for the duration of the closure.