Struct ytesrev::ditherer::Ditherer

pub struct Ditherer<T: ImageContainer + 'static> {
    pub inner: T,
    pub dither: Option<Vec<Vec<u64>>>,
    pub dither_in_time: f64,
    pub dither_out_time: f64,
    pub dither_fn: Box<dyn Fn(&T, (usize, usize)) -> u64>,
    pub direction: DitherDirection,
    // some fields omitted
}

The ditherer itself. The inner type T is the thing to be dithered

Fields

inner: T

The inner object to be dithered

dither: Option<Vec<Vec<u64>>>

The time each pixel will be dithered in

dither_in_time: f64

How long the ditherer has been dithering in for

dither_out_time: f64

How long the ditherer has been dithering out for

dither_fn: Box<dyn Fn(&T, (usize, usize)) -> u64>

The function to determine what regionso to dither first

direction: DitherDirection

The direction to dither in

Methods

impl<T: ImageContainer> Ditherer<T>

pub fn new(inner: T) -> Ditherer<T>

Create a new ditherer instance, dithering using alpha_dither_fn.

pub fn dithered_in(inner: T) -> Ditherer<T>

Create a new ditherer that is already dithered in

pub fn dithering_in(inner: T) -> Ditherer<T>

Create a new ditherer that is already dithered in

pub fn with_dither_fn<F: Fn(&T, (usize, usize)) -> u64>(
    self,
    f: F
) -> Ditherer<T> where
    F: 'static, 

Convert a ditherer to use a specific dither function

pub fn with_direction(self, dir: DitherDirection) -> Ditherer<T>

Convert a ditherer to use a specific direction function

pub fn dither_in(&mut self)

Start dither in this object

pub fn dither_out(&mut self)

Start dither out this object

Trait Implementations

impl<T: ImageContainer> Drawable for Ditherer<T>

fn content(&self) -> Vec<&dyn Drawable>

What this object contains

fn content_mut(&mut self) -> Vec<&mut dyn Drawable>

What this object contains, mutably

fn load(&mut self)

Load all content

fn update(&mut self, dt: f64)

Tick the object

fn step(&mut self)

When the user presses space, the state of the presentation is advanced. This method is what is called.

fn state(&self) -> State

What state the object is in

fn draw(
    &self,
    canvas: &mut Canvas<Window>,
    pos: &Position,
    settings: DrawSettings
)

Draw everything

fn register(&mut self)

Register all content. This is mostly just used by [LatexObj]s, that need to be registered before loaded.

fn event(&mut self, e: Event)

When any event occurs

impl<T: ImageContainer + KnownSize> KnownSize for Ditherer<T>

fn width(&self) -> usize

The width of the object

fn height(&self) -> usize

The height of the object

impl<T: ImageContainer + KnownSize> ImageContainer for Ditherer<T>

fn get_data(&self) -> &Vec<u8>

Retrieve the data in the image

fn get_data_mut(&mut self) -> &mut Vec<u8>

Retrieve the data in the image, mutably

fn into_data(self) -> Vec<u8>

Retrieve the data in the image, consuming the object

fn as_knownsize(&self) -> &dyn KnownSize

Convert the object to a dynamic KnownSize object, as rust doesn't support calling KnownSize -methods directly on this object

impl<T: ImageContainer> Send for Ditherer<T>