Struct spectrusty::chip::scld::frame_cache::ScldFrameRef

pub struct ScldFrameRef<'a, V> {
    pub screen0: &'a ScreenArray,
    pub screen1: &'a ScreenArray,
    pub frame_cache0: &'a UlaFrameCache<V>,
    pub frame_cache1: &'a UlaFrameCache<V>,
}

A reference to primary and secondary screen data with relevant frame caches.

Fields

screen0: &'a ScreenArray

primary screen data

screen1: &'a ScreenArray

secondary screen data

frame_cache0: &'a UlaFrameCache<V>

primary screen frame cache

frame_cache1: &'a UlaFrameCache<V>

secondary screen frame cache

Implementations

impl<'a, V> ScldFrameRef<'a, V>

pub fn new(
    screen0: &'a ScreenArray,
    frame_cache0: &'a UlaFrameCache<V>,
    screen1: &'a ScreenArray,
    frame_cache1: &'a UlaFrameCache<V>
) -> Self

Examples found in repository

src/chip/scld/frame_cache.rs (line 197)

    pub fn new(
            source: SourceMode,
            screen0: &'a ScreenArray,
            frame_cache0: &'a UlaFrameCache<V>,
            screen1: &'a ScreenArray,
            frame_cache1: &'a UlaFrameCache<V>,
            mut source_changes: I
        ) -> Self
    {
        let line = 0;
        let line_iter = EMPTY_LINE_ITER;
        let (next_change_at, next_source) = source_changes.next()
                    .map(|tsm| vtm_next::<V>(tsm, line as Ts))
                    .unwrap_or_else(||
                        ( VFrameTs::max_value(), source )
                    );
        let mut prod = ScldFrameProducer {
            frame_ref: ScldFrameRef::new(screen0, frame_cache0, screen1, frame_cache1),
            line,
            next_source,
            next_change_at,
            source_changes,
            source,
            line_iter
        };
        prod.update_iter();
        prod
    }

src/chip/plus/frame_cache.rs (lines 71-74)

    pub fn new(
            swap_screens: bool,
            source: SourceMode,
            screen0: &'a ScreenArray,
            frame_cache0: &'a UlaFrameCache<V>,
            screen1: &'a ScreenArray,
            frame_cache1: &'a UlaFrameCache<V>,
            screen_shadow0: &'a ScreenArray,
            frame_cache_shadow0: &'a UlaFrameCache<V>,
            screen_shadow1: &'a ScreenArray,
            frame_cache_shadow1: &'a UlaFrameCache<V>,
            mut screen_changes: IS,
            source_changes: IM
        ) -> Self
    {
        let swap_at = screen_changes.next()
                      .map(|ts| vc_to_line::<V>(ts, 0))
                      .unwrap_or_else(VFrameTs::max_value);
        let mut scld_frame_prod = ScldFrameProducer::new(
            source,
            screen0, frame_cache0,
            screen1, frame_cache1,
            source_changes
        );
        let mut shadow_frame = ScldFrameRef::new(
            screen_shadow0, frame_cache_shadow0,
            screen_shadow1, frame_cache_shadow1,
        );
        if swap_screens {
            scld_frame_prod.swap_frame(&mut shadow_frame);
        }
        PlusFrameProducer {
            scld_frame_prod,
            shadow_frame,
            screen_changes,
            swap_at
        }
    }