Struct spectrusty::video::Renderer

pub struct Renderer<VD, BI> {
    pub border: BorderColor,
    pub frame_image_producer: VD,
    pub border_changes: BI,
    pub border_size: BorderSize,
    pub invert_flash: bool,
}

Implements a method to render an image of a video frame for classic ZX Spectrum low resolution modes.

Fields

border: BorderColor

A border color at the beginning of the frame.

frame_image_producer: VD

An iterator of ink/paper pixels and attributes by line.

border_changes: BI

Changes to border color registered with timestamps.

border_size: BorderSize

Determines the size of the rendered screen.

invert_flash: bool

Flash state.

Implementations

impl<VD, BI> Renderer<VD, BI>where
    VD: VideoFrameDataIterator,
    BI: Iterator<Item = VideoTsData3>,

pub fn render_pixels<'a, B: PixelBuffer<'a>, P: Palette<Pixel = B::Pixel>, V: VideoFrame>(
    self,
    buffer: &'a mut [u8],
    pitch: usize
)

Examples found in repository

src/chip/ula/video.rs (line 125)

    fn render_video_frame<'a, B: PixelBuffer<'a>, P: Palette<Pixel=B::Pixel>>(
            &mut self,
            buffer: &'a mut [u8],
            pitch: usize,
            border_size: BorderSize
        )
    {
        self.create_renderer(border_size).render_pixels::<B, P, V>(buffer, pitch)
    }

src/chip/ula128/video.rs (line 126)

    fn render_video_frame<'a, B: PixelBuffer<'a>, P: Palette<Pixel=B::Pixel>>(
            &mut self,
            buffer: &'a mut [u8],
            pitch: usize,
            border_size: BorderSize
        )
    {
        create_ula128_renderer(border_size,
                               &mut self.ula,
                               self.beg_screen_shadow,
                               &self.shadow_frame_cache,
                               &mut self.screen_changes)
        .render_pixels::<B, P, Self::VideoFrame>(buffer, pitch)
    }

src/chip/ula3/video.rs (line 99)

    fn render_video_frame<'a, B: PixelBuffer<'a>, P: Palette<Pixel=B::Pixel>>(
            &mut self,
            buffer: &'a mut [u8],
            pitch: usize,
            border_size: BorderSize
        )
    {
        create_ula128_renderer(border_size,
                               &mut self.ula,
                               self.beg_screen_shadow,
                               &self.shadow_frame_cache,
                               &mut self.screen_changes)
        .render_pixels::<B, P, Self::VideoFrame>(buffer, pitch)
    }

Trait Implementations

impl<VD: Debug, BI: Debug> Debug for Renderer<VD, BI>

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

Formats the value using the given formatter.