Struct kas::draw::DrawIface

pub struct DrawIface<'a, DS>
where
    DS: DrawSharedImpl,
{ /* private fields */ }

Draw interface object

Draw and extension traits such as DrawRounded provide draw functionality over this object.

This type is used to present a unified mid-level draw interface, as available from crate::theme::DrawCx::draw_device. A concrete DrawIface object may be obtained via downcast, e.g.:

impl CircleWidget {
    fn draw(&mut self, mut draw: DrawCx) {
        // This type assumes usage of kas_wgpu without a custom draw pipe:
        type DrawIface = DrawIface<kas_wgpu::draw::DrawPipe<()>>;
        if let Some(mut draw) = DrawIface::downcast_from(draw.draw_device()) {
            draw.circle(self.rect.into(), 0.9, Rgba::BLACK);
        }
    }
}

Note that this object is little more than a mutable reference to application shared draw state. As such, it is normal to pass a new copy created via DrawIface::re as a method argument. (Note that Rust automatically “reborrows” reference types passed as method arguments, but cannot do so automatically for structs containing references.)

Implementations

impl<'a, DS> DrawIface<'a, DS>

where DS: DrawSharedImpl,

pub fn downcast_from(obj: &'a mut dyn Draw) -> Option<DrawIface<'a, DS>>

Attempt to downcast a &mut dyn Draw to a concrete DrawIface object

Note: Rust does not (yet) support trait-object-downcast: it not possible to cast from &mut dyn Draw to (for example) &mut dyn DrawRounded. Instead, the target type must be the implementing object, which is provided by the graphics backend (e.g. kas_wgpu). See documentation on this type for an example, or examine clock.rs.

pub fn re<'b>(&'b mut self) -> DrawIface<'b, DS>

where 'a: 'b,

Reborrow with a new lifetime

pub fn new_pass( &mut self, rect: Rect, offset: Offset, class: PassType ) -> DrawIface<'_, DS>

Add a draw pass

Adds a new draw pass. Passes affect draw order (operations in new passes happen after their parent pass), may clip drawing to a “clip rect” (see Draw::get_clip_rect) and may offset (translate) draw operations.

Case class == PassType::Clip: the new pass is derived from parent_pass; rect and offset are specified relative to this parent and the intersecton of rect and the parent’s “clip rect” is used. be clipped to rect (expressed in the parent’s coordinate system).

Case class == PassType::Overlay: the new pass is derived from the base pass (i.e. the window). Draw operations still happen after those in parent_pass.

Trait Implementations

impl<'a, DS> Draw for DrawIface<'a, DS>

where DS: DrawSharedImpl,

fn shared(&mut self) -> &mut dyn DrawShared

Access shared draw state

fn animate(&mut self)

Request redraw at the next frame time

fn animate_at(&mut self, time: Instant)

Request a redraw at a specific time

fn get_pass(&self) -> PassId

Get the current draw pass

fn new_dyn_pass<'b>( &'b mut self, rect: Rect, offset: Offset, class: PassType ) -> Box<dyn Draw + 'b>

Add a draw pass

fn get_clip_rect(&self) -> Rect

Get drawable rect for a draw pass

fn rect(&mut self, rect: Quad, col: Rgba)

Draw a rectangle of uniform colour

fn frame(&mut self, outer: Quad, inner: Quad, col: Rgba)

Draw a frame of uniform colour

fn image(&mut self, id: ImageId, rect: Quad)

Draw the image in the given rect

fn text(&mut self, rect: Rect, text: &TextDisplay, col: Rgba)

Draw text with a colour

fn text_effects( &mut self, rect: Rect, text: &TextDisplay, col: Rgba, effects: &[Effect<()>] )

Draw text with a single color and effects

fn text_effects_rgba( &mut self, rect: Rect, text: &TextDisplay, effects: &[Effect<Rgba>] )

Draw text with effects (including Rgba color)

impl<'a, DS> DrawRounded for DrawIface<'a, DS>

where DS: DrawSharedImpl, <DS as DrawSharedImpl>::Draw: DrawRoundedImpl,

fn rounded_line(&mut self, p1: Vec2, p2: Vec2, radius: f32, col: Rgba)

Draw a line with rounded ends and uniform colour

fn circle(&mut self, rect: Quad, inner_radius: f32, col: Rgba)

Draw a circle or oval of uniform colour

fn circle_2col(&mut self, rect: Quad, col1: Rgba, col2: Rgba)

Draw a circle or oval with two colours

fn rounded_frame( &mut self, outer: Quad, inner: Quad, inner_radius: f32, col: Rgba )

Draw a frame with rounded corners and uniform colour

fn rounded_frame_2col(&mut self, outer: Quad, inner: Quad, c1: Rgba, c2: Rgba)

Draw a frame with rounded corners with two colours

impl<'a, DS> DrawShaded for DrawIface<'a, DS>

where DS: DrawSharedImpl, <DS as DrawSharedImpl>::Draw: DrawShadedImpl,

fn shaded_square(&mut self, rect: Quad, norm: (f32, f32), col: Rgba)

Add a shaded square to the draw buffer

fn shaded_circle(&mut self, rect: Quad, norm: (f32, f32), col: Rgba)

Add a shaded circle to the draw buffer

fn shaded_square_frame( &mut self, outer: Quad, inner: Quad, norm: (f32, f32), outer_col: Rgba, inner_col: Rgba )

Add a shaded frame with square corners to the draw buffer

fn shaded_round_frame( &mut self, outer: Quad, inner: Quad, norm: (f32, f32), col: Rgba )

Add a shaded frame with rounded corners to the draw buffer