Struct kas::draw::DrawIface

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

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 DrawHandle::draw_device. A concrete DrawIface object may be obtained via downcast, e.g.:

impl CircleWidget {
    fn draw(&self, draw_handle: &mut dyn DrawHandle) {
        // 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_handle.draw_device()) {
            draw.circle(self.rect.into(), 0.9, Rgba::BLACK);
        }
    }
}

Note that this object is little more than a mutable reference to the shell’s per-window draw state. As such, it is normal to pass a new copy created via DrawIface::reborrow 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 + 'a)) -> Option<DrawIface<'a, DS>>

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

pub fn reborrow<'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 DrawIface::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, 

pub fn get_pass(&self) -> PassId

Get the current draw pass

pub fn get_fields_as_any_mut(
    &mut self
) -> (&mut (dyn Any + 'static), &mut (dyn Any + 'static))

pub fn new_dyn_pass(
    &'b mut self,
    rect: Rect,
    offset: Offset,
    class: PassType
) -> ValueA<dyn Draw + 'b, [usize; 4]>

Add a draw pass

pub fn get_clip_rect(&self) -> Rect

Get drawable rect for a draw pass

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

Draw a rectangle of uniform colour

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

Draw a frame of uniform colour

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

Draw the image in the given rect

pub fn text(&mut self, pos: Vec2, text: &TextDisplay, col: Rgba)

Draw text with a colour

pub fn text_col_effects(
    &mut self,
    pos: Vec2,
    text: &TextDisplay,
    col: Rgba,
    effects: &[Effect<()>]
)

Draw text with a colour and effects

pub fn text_effects(
    &mut self,
    pos: Vec2,
    text: &TextDisplay,
    effects: &[Effect<Rgba>]
)

Draw text with effects

impl<'a, DS> DrawRounded for DrawIface<'a, DS> where
    DS: DrawSharedImpl,
    <DS as DrawSharedImpl>::Draw: DrawRoundedImpl, 

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

Draw a line with rounded ends and uniform colour

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

Draw a circle or oval of uniform colour

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

Draw a circle or oval with two colours

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

Draw a frame with rounded corners and uniform colour

pub 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, 

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

Add a shaded square to the draw buffer

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

Add a shaded circle to the draw buffer

pub 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

pub 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