Struct spectrusty::chip::plus::UlaPlus

pub struct UlaPlus<U: Video> { /* fields omitted */ }

Provides ULAplus screen and color modes for Ula, Ula128 and Ula3.

Implementations

impl<'a, U> UlaPlus<U> where
    U: UlaPlusInner<'a>, 

pub fn can_read_scld_mode(&mut self) -> bool

Returns true if reading the 0xFF port returns the previous write or false if bus data is being read.

pub fn enable_reading_scld_mode(&mut self, enable_reading: bool)

Determines if reading the 0xFF port returns the previous write or bus data.

pub fn is_ulaplus_enabled(&self) -> bool

Returns true if ULAplus modes and ports are enabled or false otherwise.

pub fn enable_ulaplus_modes(&mut self, enable: bool)

Controls the ULAplus ports and graphics availability.

When disabled, ULAplus ports become available to the underlying devices and the screen and color modes are being reset to the default. However, palette entries are left unmodified. The last register port value written is also left unmodified.

When enabled, ULAplus ports become responsive again but the screen mode is not restored unless it has been previously written to 0xFF port. In this instance the screen mode gets restored from the last value written to 0xFF port. The color mode is always being restored.

pub fn render_mode(&self) -> RenderMode

Returns the current rendering mode.

pub fn source_mode(&self) -> SourceMode

Returns the current source mode.

pub fn ulaplus_palette(&self) -> &UlaPlusPalette

Returns the current palette view.

pub fn ulaplus_palette_mut(&mut self) -> &mut UlaPlusPalette

Returns the mutable reference to the current palette.

Trait Implementations

impl<A, U> AudioFrame<A> for UlaPlus<U> where
    A: Blep,
    U: Video + AudioFrame<A>, 

pub fn ensure_audio_frame_time(
    &self,
    blep: &mut A,
    sample_rate: u32,
    cpu_hz: f64
)

Sets up the Blep time rate and ensures there is enough room for the single frame's audio data.

pub fn get_audio_frame_end_time(&self) -> FTs

Returns a timestamp to be passed to Blep to end the frame.

pub fn end_audio_frame(&self, blep: &mut B) -> usize

Calls Blep::end_frame to finalize the frame and prepare it for rendition.

impl<A, U> AyAudioFrame<A> for UlaPlus<U> where
    A: Blep,
    U: Video + AyAudioFrame<A>, 

pub fn render_ay_audio_frame<V: AmpLevels<A::SampleDelta>>(
    &mut self,
    blep: &mut A,
    chans: [usize; 3]
)

Renders square-wave pulses via Blep interface.

impl<U: Clone + Video> Clone for UlaPlus<U> where
    U::VideoFrame: Clone,
    U::VideoFrame: Clone, 

pub fn clone(&self) -> UlaPlus<U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<U, B, X> ControlUnit for UlaPlus<U> where
    U: for<'a> UlaPlusInner<'a> + ControlUnit<BusDevice = B> + UlaControlExt + MemoryAccess<MemoryExt = X> + Memory<Timestamp = VideoTs> + Io<Timestamp = VideoTs, WrIoBreak = (), RetiBreak = ()>,
    B: BusDevice,
    B::Timestamp: From<VFrameTs<U::VideoFrame>>,
    X: MemoryExtension, 

type BusDevice = U::BusDevice

A type of a chain of emulated peripheral devices should be declared here.

pub fn bus_device_mut(&mut self) -> &mut Self::BusDevice

Returns a mutable reference to the instance of the first bus device in the device chain.

pub fn bus_device_ref(&self) -> &Self::BusDevice

Returns a reference to the the instance of the first bus device in the device chain.

pub fn into_bus_device(self) -> Self::BusDevice

Destructs self and returns the instance of the bus device.

pub fn reset<C: Cpu>(&mut self, cpu: &mut C, hard: bool)

Performs a system reset.

pub fn nmi<C: Cpu>(&mut self, cpu: &mut C) -> bool

Triggers a non-maskable interrupt. Returns true if NMI was accepted.

pub fn execute_next_frame<C: Cpu>(&mut self, cpu: &mut C)

Conditionally prepares the internal state for the next frame and executes instructions on the cpu as fast as possible, until the near end of that frame.

pub fn ensure_next_frame(&mut self)

Conditionally prepares the internal state for the next frame, advances the frame counter, and wraps the T-state counter if it is near the end of a frame.

pub fn execute_single_step<C: Cpu, F: FnOnce(CpuDebug)>(
    &mut self,
    cpu: &mut C,
    debug: Option<F>
) -> Result<(), ()>

Executes a single instruction on the cpu with the option to pass a debugging function.

impl<U> Debug for UlaPlus<U> where
    U: Debug + Video, 

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

Formats the value using the given formatter.

impl<U> Default for UlaPlus<U> where
    U: Video + Default, 

pub fn default() -> Self

Returns the "default value" for a type.

impl<'de, U: Video> Deserialize<'de> for UlaPlus<U> where
    U: Deserialize<'de>, 

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<U> EarIn for UlaPlus<U> where
    U: Video + EarIn, 

pub fn set_ear_in(&mut self, ear_in: bool, delta_fts: u32)

Sets EAR IN bit state after the provided interval in ∆ T-states counted from the last recorded change.

pub fn feed_ear_in<I>(
    &mut self,
    fts_deltas: I,
    max_frames_threshold: Option<usize>
) where
    I: Iterator<Item = NonZeroU32>, 

Feeds the EAR IN buffer with changes.

pub fn purge_ear_in_changes(&mut self, ear_in: bool)

Removes all buffered so far EAR IN changes.

pub fn read_ear_in_count(&self) -> u32

Returns the counter of how many times the EAR input line was read since the beginning of the current frame.

pub fn read_ear_mode(&self) -> ReadEarMode

Returns the current mode.

pub fn set_read_ear_mode(&mut self, mode: ReadEarMode)

Changes the current mode.

impl<A, U> EarInAudioFrame<A> for UlaPlus<U> where
    A: Blep,
    U: Video + EarInAudioFrame<A>, 

pub fn render_ear_in_audio_frame<V: AmpLevels<A::SampleDelta>>(
    &self,
    blep: &mut A,
    channel: usize
)

Renders EAR input as square-wave pulses via Blep interface.

impl<A, U> EarMicOutAudioFrame<A> for UlaPlus<U> where
    A: Blep,
    U: Video + EarMicOutAudioFrame<A>, 

pub fn render_earmic_out_audio_frame<V: AmpLevels<A::SampleDelta>>(
    &self,
    blep: &mut A,
    channel: usize
)

Renders EAR/MIC output as square-wave pulses via Blep interface.

impl<U: HostConfig + Video> HostConfig for UlaPlus<U>

pub const CPU_HZ: u32

The number of CPU cycles (T-states) per second.

pub const FRAME_TSTATES: FTs

The number of CPU cycles (T-states) in a single execution frame.

pub fn effective_cpu_rate(multiplier: f64) -> f64

Returns the CPU rate (T-states / second) after multiplying it by the multiplier.

pub fn effective_frame_duration_nanos(multiplier: f64) -> u32

Returns the duration of a single execution frame in nanoseconds after multiplying the CPU rate by the multiplier.

pub fn effective_frame_duration(multiplier: f64) -> Duration

Returns the duration of a single execution frame after multiplying the CPU rate by the multiplier.

pub fn frame_duration_nanos() -> u32

Returns the duration of a single execution frame in nanoseconds.

pub fn frame_duration() -> Duration

Returns the duration of a single execution frame.

impl<U> InnerAccess for UlaPlus<U> where
    U: Video, 

type Inner = U

pub fn inner_ref(&self) -> &Self::Inner

Returns a reference to the inner chipset.

pub fn inner_mut(&mut self) -> &mut Self::Inner

Returns a mutable reference to the inner chipset.

pub fn into_inner(self) -> Self::Inner

Destructs self and returns the inner chipset.

impl<'a, U> Io for UlaPlus<U> where
    U: UlaPlusInner<'a> + Io<Timestamp = VideoTs, WrIoBreak = (), RetiBreak = ()>, 

type Timestamp = VideoTs

This type is being used for timestamping I/O operations. See also [Clock::Timestamp].

type WrIoBreak = ()

A value of this type is returned when a break is being requested by [Io::write_io].

type RetiBreak = ()

A value of this type is returned when a break is being requested by [Io::reti].

pub fn is_irq(&mut self, ts: VideoTs) -> bool

Should return true if the interrupt request signal - the INT line - is active.

pub fn read_io(&mut self, port: u16, ts: VideoTs) -> (u8, Option<NonZeroU16>)

Called during the IO_IORQ cycle when executing one of the IN instructions.

pub fn write_io(
    &mut self,
    port: u16,
    data: u8,
    ts: VideoTs
) -> (Option<()>, Option<NonZeroU16>)

Called during the IO_IORQ cycle when executing one of the OUT instructions.

pub fn irq_data(
    &mut self,
    pc: u16,
    timestamp: Self::Timestamp
) -> (u8, Option<NonZeroU16>)

Called during the INT_IORQ cycle when the maskable interrupt has been requested and accepted.

pub fn reti(
    &mut self,
    address: u16,
    timestamp: Self::Timestamp
) -> Option<Self::RetiBreak>

When RETI instruction is being executed this method is being called to update the device implementation instance, so another interrupt signal can be set up if necessary.

impl<U> KeyboardInterface for UlaPlus<U> where
    U: Video + KeyboardInterface, 

pub fn get_key_state(&self) -> ZXKeyboardMap

Reads the current state of the keyboard.

pub fn set_key_state(&mut self, keymap: ZXKeyboardMap)

Sets the state of the keyboard.

impl<'a, U> Memory for UlaPlus<U> where
    U: UlaPlusInner<'a> + Memory<Timestamp = VideoTs>, 

type Timestamp = VideoTs

This type is being used for timestamping memory operations. See also [Clock::Timestamp].

pub fn read_debug(&self, addr: u16) -> u8

Should return a single byte read from the memory present at the given address.

pub fn read_mem(&self, addr: u16, ts: VideoTs) -> u8

Should return a single byte read from the memory present at the given address.

pub fn read_mem16(&self, addr: u16, ts: VideoTs) -> u16

Should return the unaligned, 2 consecutive bytes from the memory present at the given address as a 16-bit unsigned integer in a LE (least significant byte first) order.

pub fn read_opcode(&mut self, pc: u16, ir: u16, ts: VideoTs) -> u8

Should return a single byte read from the memory present at the given pc address.

pub fn write_mem(&mut self, addr: u16, val: u8, ts: VideoTs)

Should write a byte value into the memory at the given address.

impl<U> MemoryAccess for UlaPlus<U> where
    U: Video + MemoryAccess, 

type Memory = U::Memory

type MemoryExt = U::MemoryExt

pub fn memory_ext_ref(&self) -> &Self::MemoryExt

Returns a read-only reference to the memory extension.

pub fn memory_ext_mut(&mut self) -> &mut Self::MemoryExt

Returns a mutable reference to the memory extension.

pub fn memory_mut(&mut self) -> &mut Self::Memory

Returns a mutable reference to the memory.

pub fn memory_ref(&self) -> &Self::Memory

Returns a reference to the memory.

pub fn memory_with_ext_mut(
    &mut self
) -> (&mut Self::Memory, &mut Self::MemoryExt)

Returns mutable references to both the memory and the memory extension.

impl<'a, U: 'a> MicOut<'a> for UlaPlus<U> where
    U: Video + MicOut<'a>, 

type PulseIter = <U as MicOut<'a>>::PulseIter

pub fn mic_out_pulse_iter(&'a self) -> Self::PulseIter

Returns a frame buffered MIC output as a pulse iterator.

impl<'a, U> ScreenDataProvider for UlaPlus<U> where
    U: UlaPlusInner<'a>,
    Self: Video, 

pub fn get_screen_mode(&self) -> ScrMode

Should return a currently selected screen mode.

pub fn set_screen_mode(&mut self, mode: ScrMode) -> bool

Should set a requested screen mode and return true. If the provided mode can not be set this method should return false.

pub fn screen_primary_ref(&self) -> &ScreenArray

Should return a reference to the primary screen data.

pub fn screen_primary_mut(&mut self) -> &mut ScreenArray

Should return a mutable reference to the primary screen data.

pub fn screen_secondary_ref(&self) -> &ScreenArray

Should return a reference to the secondary screen data.

pub fn screen_secondary_mut(&mut self) -> &mut ScreenArray

Should return a mutable reference to the secondary screen data.

pub fn screen_palette_ref(&self) -> &[u8; 64]

Should return a reference to the ULAplus palette.

pub fn screen_palette_mut(&mut self) -> &mut [u8; 64]

Should return a mutable reference to the ULAplus palette.

impl<U: Video> Serialize for UlaPlus<U> where
    U: Serialize, 

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'a, U> UlaControl for UlaPlus<U> where
    U: UlaControl + UlaPlusInner<'a>, 

pub fn has_late_timings(&self) -> bool

Returns the state of the "late timings" mode.

pub fn set_late_timings(&mut self, late_timings: bool)

Sets the "late timings" mode on or off.

pub fn ula128_mem_port_value(&self) -> Option<Ula128MemFlags>

Returns the last value sent to the memory port 0x7FFD if supported.

pub fn set_ula128_mem_port_value(&mut self, value: Ula128MemFlags) -> bool

Sets the current value of the memory port 0x7FFD. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn ula3_ctrl_port_value(&self) -> Option<Ula3CtrlFlags>

Returns the last value sent to the memory port 0x1FFD if supported.

pub fn set_ula3_ctrl_port_value(&mut self, value: Ula3CtrlFlags) -> bool

Sets the current value of the memory port 0x1FFD. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn scld_ctrl_port_value(&self) -> Option<ScldCtrlFlags>

Returns the last value sent to the memory port 0xFF.

pub fn set_scld_ctrl_port_value(&mut self, value: ScldCtrlFlags) -> bool

Sets the current value of the memory port 0xFF. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn scld_mmu_port_value(&self) -> Option<u8>

Returns the last value sent to the memory port 0xF4.

pub fn set_scld_mmu_port_value(&mut self, value: u8) -> bool

Sets the current value of the memory port 0xF4. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn ulaplus_reg_port_value(&self) -> Option<UlaPlusRegFlags>

Returns the last value sent to the register port 0xBF3B.

pub fn set_ulaplus_reg_port_value(&mut self, value: UlaPlusRegFlags) -> bool

Sets the current value of the memory port 0xBF3B. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn ulaplus_data_port_value(&self) -> Option<u8>

Returns the last value sent to the data port 0xFF3B.

pub fn set_ulaplus_data_port_value(&mut self, value: u8) -> bool

Sets the current value of the memory port 0xFF3B. Returns true if supported. Otherwise, returns false and no writing is performed.

impl<U> UlaControlExt for UlaPlus<U> where
    U: for<'a> UlaPlusInner<'a> + ControlUnit + UlaControlExt, 

pub fn prepare_next_frame<C: MemoryContention>(
    &mut self,
    vtsc: VFrameTsCounter<U::VideoFrame, C>
) -> VFrameTsCounter<U::VideoFrame, C>

This method is used by wrappers with a different contention scheme.

pub fn ensure_next_frame_vtsc(
    &mut self
) -> VFrameTsCounter<Self::VideoFrame, Self::Contention>

impl<U> Video for UlaPlus<U> where
    U: for<'a> UlaPlusInner<'a>, 

pub const PIXEL_DENSITY: u32

The horizontal pixel density.

type VideoFrame = U::VideoFrame

The type implementing VideoFrame, that is being used by the chipset emulator.

type Contention = U::Contention

The type implementing MemoryContention, that is being used by the chipset emulator.

pub fn border_color(&self) -> BorderColor

Returns the current border color.

pub fn set_border_color(&mut self, border: BorderColor)

Force sets the border area to the given color.

pub fn render_video_frame<'b, B: PixelBuffer<'b>, P: Palette<Pixel = B::Pixel>>(
    &mut self,
    buffer: &'b mut [u8],
    pitch: usize,
    border_size: BorderSize
)

Renders last emulated frame's video data into the provided pixel buffer.

pub fn current_video_ts(&self) -> VideoTs

Returns the current value of the video T-state counter.

pub fn visible_screen_bank(&self) -> usize

Returns the screen bank index of the currently visible screen.

pub fn current_video_clock(
    &self
) -> VFrameTsCounter<Self::VideoFrame, Self::Contention>

Returns the current value of the video T-state clock.

pub fn set_video_ts(&mut self, vts: VideoTs)

Modifies the current value of the video T-state counter.

pub fn flash_state(&self) -> bool

Returns the temporary video flash attribute state.

pub fn render_size_pixels(border_size: BorderSize) -> (u32, u32)

Returns rendered screen pixel size (horizontal, vertical), including the border area, measured in pixels depending on Video::PIXEL_DENSITY.

pub fn pixel_density() -> u32

Returns the horizontal pixel density.