Struct spectrusty::chip::ula::frame_cache::UlaFrameCache

pub struct UlaFrameCache<V> {
    pub frame_pixels: [(u32, [u8; 32]); 192],
    pub frame_colors: [(u32, [u8; 32]); 192],
    pub frame_colors_coarse: [(u32, [u8; 32]); 24],
    /* private fields */
}

Spectrum’s video data frame cache.

When a byte is being written to the video memory and the video beam position has already passed the referenced screen cell, the cell value is being cached from memory before the data in memory is being modified.

The caching is performed only once per frame for each potential cell so subsequent writes to the same memory address won’t modify the cached cell value.

When a screen is being drawn the data stored in cache will override any value currently residing in video memory.

Fields

frame_pixels: [(u32, [u8; 32]); 192]

frame_colors: [(u32, [u8; 32]); 192]

frame_colors_coarse: [(u32, [u8; 32]); 24]

Implementations

impl<V> UlaFrameCache<V>

pub fn clear(&mut self)

Examples found in repository

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

    pub(super) fn cleanup_video_frame_data(&mut self) {
        self.border = self.last_border;
        self.border_out_changes.clear();
        self.frame_cache.clear();
    }

src/chip/ula3.rs (line 447)

    fn prepare_next_frame<C: MemoryContention>(
            &mut self,
            vtsc: VFrameTsCounter<Ula3VidFrame, C>
        ) -> VFrameTsCounter<Ula3VidFrame, C>
    {
        self.beg_screen_shadow = self.cur_screen_shadow;
        self.shadow_frame_cache.clear();
        self.screen_changes.clear();
        self.ula.prepare_next_frame(vtsc)
    }

src/chip/scld.rs (line 378)

    fn prepare_next_frame<C: MemoryContention>(
            &mut self,
            vtsc: VFrameTsCounter<V, C>
        ) -> VFrameTsCounter<V, C>
    {
        self.beg_ctrl_flags = self.cur_ctrl_flags;
        self.sec_frame_cache.clear();
        self.mode_changes.clear();
        self.source_changes.clear();
        self.ula.prepare_next_frame(vtsc)
    }

src/chip/ula128.rs (line 366)

    fn prepare_next_frame<C: MemoryContention>(
            &mut self,
            vtsc: VFrameTsCounter<Ula128VidFrame, C>
        ) -> VFrameTsCounter<Ula128VidFrame, C>
    {
        // println!("vis: {} nxt: {} p3: {}", self.beg_screen_shadow, self.cur_screen_shadow, self.mem_page3_bank);
        self.beg_screen_shadow = self.cur_screen_shadow;
        self.shadow_frame_cache.clear();
        self.screen_changes.clear();
        self.ula.prepare_next_frame(vtsc)
    }

src/chip/plus.rs (line 586)

    fn prepare_next_frame<C: MemoryContention>(
            &mut self,
            vtsc: VFrameTsCounter<U::VideoFrame, C>
        ) -> VFrameTsCounter<U::VideoFrame, C>
    {
        self.beg_render_mode = self.cur_render_mode;
        self.beg_source_mode = self.cur_source_mode;
        self.beg_palette = self.cur_palette;

        self.sec_frame_cache.clear();
        self.shadow_sec_frame_cache.clear();
        self.palette_changes.clear();
        self.source_changes.clear();
        self.mode_changes.clear();
        self.ula.prepare_next_frame(vtsc)
    }

impl<V: VideoFrame> UlaFrameCache<V>

pub fn update_frame_pixels<M: ZxMemory>(
    &mut self,
    memory: &M,
    _: CellCoords,
    addr: u16,
    ts: VideoTs
)

Compares the given bitmap cell coordinates with the video timestamp and depending on the result of that comparison caches (or not) the bitmap cell with the value from the memory at the given address.

Examples found in repository

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

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        match addr {
            0x4000..=0x57FF => {
                let coords = pixel_address_coords(addr);
                self.frame_cache.update_frame_pixels(&self.memory, coords, addr, ts);
            }
            0x5800..=0x5AFF => {
                let coords = color_address_coords(addr);
                self.frame_cache.update_frame_colors(&self.memory, coords, addr, ts);
            }
            _ => {}
        }
    }

src/chip/scld/video.rs (line 87)

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        let frame_cache = match addr {
            0x4000..=0x5AFF if self.mem_paged & 4 == 0 => &mut self.ula.frame_cache,
            0x6000..=0x7AFF if self.mem_paged & 8 == 0 => &mut self.sec_frame_cache,
            _ => return
        };

        if addr & 0x1800 != 0x1800 {
            let coords = pixel_address_coords(addr);
            frame_cache.update_frame_pixels(&self.ula.memory, coords, addr, ts);
        }
        else {
            let coords = color_address_coords(addr);
            frame_cache.update_frame_colors(&self.ula.memory, coords, addr, ts);
        }
    }

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

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        let frame_cache = match addr {
            0x4000..=0x5AFF => &mut self.ula.frame_cache,
            0xC000..=0xDAFF => match self.page3_screen_shadow_bank() {
                Some(false) => &mut self.ula.frame_cache,
                Some(true)  => &mut self.shadow_frame_cache,
                None => return
            }
            _ => return
        };
        if addr & 0x1800 != 0x1800 {
            let coords = pixel_address_coords(addr);
            frame_cache.update_frame_pixels(&self.ula.memory, coords, addr, ts);
        }
        else {
            let coords = color_address_coords(addr);
            frame_cache.update_frame_colors(&self.ula.memory, coords, addr, ts);
        }
    }

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

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        let maybe_shadow = match addr {
            0x4000..=0x5AFF => self.page1_screen_shadow_bank(),
            0xC000..=0xDAFF => self.page3_screen_shadow_bank(),
            _ => return
        };
        let frame_cache = match maybe_shadow {
            Some(false) => &mut self.ula.frame_cache,
            Some(true)  => &mut self.shadow_frame_cache,
            None => return
        };
        if addr & 0x1800 != 0x1800 {
            let coords = pixel_address_coords(addr);
            frame_cache.update_frame_pixels(&self.ula.memory, coords, addr, ts);
        }
        else {
            let coords = color_address_coords(addr);
            frame_cache.update_frame_colors(&self.ula.memory, coords, addr, ts);
        }
    }

src/chip/plus/video.rs (line 103)

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        let (frame_cache, memory_ref): (&mut UlaFrameCache<_>, _) = match addr {
            0x4000..=0x5AFF => match self.ula.page1_screen0_shadow_bank() {
                Some(false) => self.ula.frame_cache_mut_mem_ref(),
                Some(true) => self.ula.shadow_frame_cache_mut_mem_ref(),
                None => return
            }
            0x6000..=0x7AFF => match self.ula.page1_screen1_shadow_bank() {
                Some(false) => (&mut self.sec_frame_cache, self.ula.memory_ref()),
                Some(true) => (&mut self.shadow_sec_frame_cache, self.ula.memory_ref()),
                None => return
            }
            0xC000..=0xDAFF => match self.ula.page3_screen0_shadow_bank() {
                Some(false) => self.ula.frame_cache_mut_mem_ref(),
                Some(true) => self.ula.shadow_frame_cache_mut_mem_ref(),
                None => return
            }
            0xE000..=0xFAFF => match self.ula.page3_screen1_shadow_bank() {
                Some(false) => (&mut self.sec_frame_cache, self.ula.memory_ref()),
                Some(true) => (&mut self.shadow_sec_frame_cache, self.ula.memory_ref()),
                None => return
            }
            _ => return
        };

        if addr & 0x1800 != 0x1800 {
            let coords = pixel_address_coords(addr);
            frame_cache.update_frame_pixels(memory_ref, coords, addr, ts);
        }
        else {
            let coords = color_address_coords(addr);
            frame_cache.update_frame_colors(memory_ref, coords, addr, ts);
        }
    }

pub fn update_frame_colors<M: ZxMemory>(
    &mut self,
    memory: &M,
    _: CellCoords,
    addr: u16,
    ts: VideoTs
)

Compares the given attribute cell coordinates with the video timestamp and depending on the result of that comparison caches (or not) the attribute cell or cells with the value from the memory at the given address.

Examples found in repository

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

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        match addr {
            0x4000..=0x57FF => {
                let coords = pixel_address_coords(addr);
                self.frame_cache.update_frame_pixels(&self.memory, coords, addr, ts);
            }
            0x5800..=0x5AFF => {
                let coords = color_address_coords(addr);
                self.frame_cache.update_frame_colors(&self.memory, coords, addr, ts);
            }
            _ => {}
        }
    }

src/chip/scld/video.rs (line 91)

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        let frame_cache = match addr {
            0x4000..=0x5AFF if self.mem_paged & 4 == 0 => &mut self.ula.frame_cache,
            0x6000..=0x7AFF if self.mem_paged & 8 == 0 => &mut self.sec_frame_cache,
            _ => return
        };

        if addr & 0x1800 != 0x1800 {
            let coords = pixel_address_coords(addr);
            frame_cache.update_frame_pixels(&self.ula.memory, coords, addr, ts);
        }
        else {
            let coords = color_address_coords(addr);
            frame_cache.update_frame_colors(&self.ula.memory, coords, addr, ts);
        }
    }

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

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        let frame_cache = match addr {
            0x4000..=0x5AFF => &mut self.ula.frame_cache,
            0xC000..=0xDAFF => match self.page3_screen_shadow_bank() {
                Some(false) => &mut self.ula.frame_cache,
                Some(true)  => &mut self.shadow_frame_cache,
                None => return
            }
            _ => return
        };
        if addr & 0x1800 != 0x1800 {
            let coords = pixel_address_coords(addr);
            frame_cache.update_frame_pixels(&self.ula.memory, coords, addr, ts);
        }
        else {
            let coords = color_address_coords(addr);
            frame_cache.update_frame_colors(&self.ula.memory, coords, addr, ts);
        }
    }

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

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        let maybe_shadow = match addr {
            0x4000..=0x5AFF => self.page1_screen_shadow_bank(),
            0xC000..=0xDAFF => self.page3_screen_shadow_bank(),
            _ => return
        };
        let frame_cache = match maybe_shadow {
            Some(false) => &mut self.ula.frame_cache,
            Some(true)  => &mut self.shadow_frame_cache,
            None => return
        };
        if addr & 0x1800 != 0x1800 {
            let coords = pixel_address_coords(addr);
            frame_cache.update_frame_pixels(&self.ula.memory, coords, addr, ts);
        }
        else {
            let coords = color_address_coords(addr);
            frame_cache.update_frame_colors(&self.ula.memory, coords, addr, ts);
        }
    }

src/chip/plus/video.rs (line 107)

    pub(super) fn update_frame_cache(&mut self, addr: u16, ts: VideoTs) {
        let (frame_cache, memory_ref): (&mut UlaFrameCache<_>, _) = match addr {
            0x4000..=0x5AFF => match self.ula.page1_screen0_shadow_bank() {
                Some(false) => self.ula.frame_cache_mut_mem_ref(),
                Some(true) => self.ula.shadow_frame_cache_mut_mem_ref(),
                None => return
            }
            0x6000..=0x7AFF => match self.ula.page1_screen1_shadow_bank() {
                Some(false) => (&mut self.sec_frame_cache, self.ula.memory_ref()),
                Some(true) => (&mut self.shadow_sec_frame_cache, self.ula.memory_ref()),
                None => return
            }
            0xC000..=0xDAFF => match self.ula.page3_screen0_shadow_bank() {
                Some(false) => self.ula.frame_cache_mut_mem_ref(),
                Some(true) => self.ula.shadow_frame_cache_mut_mem_ref(),
                None => return
            }
            0xE000..=0xFAFF => match self.ula.page3_screen1_shadow_bank() {
                Some(false) => (&mut self.sec_frame_cache, self.ula.memory_ref()),
                Some(true) => (&mut self.shadow_sec_frame_cache, self.ula.memory_ref()),
                None => return
            }
            _ => return
        };

        if addr & 0x1800 != 0x1800 {
            let coords = pixel_address_coords(addr);
            frame_cache.update_frame_pixels(memory_ref, coords, addr, ts);
        }
        else {
            let coords = color_address_coords(addr);
            frame_cache.update_frame_colors(memory_ref, coords, addr, ts);
        }
    }

pub fn apply_snow_interference(
    &mut self,
    screen: &ScreenArray,
    _: CellCoords,
    snow: u8
)

Caches the bitmap and attribute cell at the given coordinates with the snow distortion applied.

Examples found in repository

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

    pub(super) fn update_snow_interference(&mut self, ts: VideoTs, ir: u16) {
        if UlaMemoryContention.is_contended_address(ir) {
            if let Some(coords) = V::snow_interference_coords(ts) {
                let screen = self.memory.screen_ref(0).unwrap();
                self.frame_cache.apply_snow_interference(screen, coords, ir as u8)
            }
        }
    }

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

    pub(super) fn update_snow_interference(&mut self, ts: VideoTs, ir: u16) {
        if self.memory_contention().is_contended_address(ir) {
            if let Some(coords) = Ula128VidFrame::snow_interference_coords(ts) {
                let (screen, frame_cache) = if self.cur_screen_shadow {
                    (self.ula.memory.screen_ref(1).unwrap(), &mut self.shadow_frame_cache)
                }
                else {
                    (self.ula.memory.screen_ref(0).unwrap(), &mut self.ula.frame_cache)
                };
                frame_cache.apply_snow_interference(screen, coords, ir as u8);
            }
        }
    }

Trait Implementations

impl<V: Clone> Clone for UlaFrameCache<V>

fn clone(&self) -> UlaFrameCache<V>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V> Debug for UlaFrameCache<V>

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

Formats the value using the given formatter.

impl<V> Default for UlaFrameCache<V>

fn default() -> Self

Returns the “default value” for a type.