6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2025-08-07 23:25:00 +00:00
Code Issues Projects Releases Wiki Activity

Commuted remaining Electron underscores. It would be nice also to factor out the video, but the time hasn't come yet.

Browse Source
This commit is contained in:
Thomas Harte
2016-12-03 13:01:01 -05:00
parent 4fac538a57
commit eb3a1fbfb7
2 changed files with 286 additions and 287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

511
Machines/Electron/Electron.cpp
View File

@@ -37,30 +37,29 @@ namespace {
#define graphics_column(v) ((((v) & 127) - first_graphics_cycle + 128) & 127) #define graphics_column(v) ((((v) & 127) - first_graphics_cycle + 128) & 127)
Machine::Machine() : Machine::Machine() :
_interrupt_control(0), interrupt_control_(0),
_interrupt_status(Interrupt::PowerOnReset | Interrupt::TransmitDataEmpty | 0x80), interrupt_status_(Interrupt::PowerOnReset | Interrupt::TransmitDataEmpty | 0x80),
_frameCycles(0), frame_cycles_(0),
_displayOutputPosition(0), display_output_position_(0),
_audioOutputPosition(0), audio_output_position_(0),
_current_pixel_line(-1), current_pixel_line_(-1),
_use_fast_tape_hack(false), use_fast_tape_hack_(false),
_crt(nullptr), phase_(0)
_phase(0)
{ {
memset(_key_states, 0, sizeof(_key_states)); memset(key_states_, 0, sizeof(key_states_));
memset(_palette, 0xf, sizeof(_palette)); memset(palette_, 0xf, sizeof(palette_));
for(int c = 0; c < 16; c++) for(int c = 0; c < 16; c++)
memset(_roms[c], 0xff, 16384); memset(roms_[c], 0xff, 16384);
_tape.set_delegate(this); tape_.set_delegate(this);
set_clock_rate(2000000); set_clock_rate(2000000);
} }
void Machine::setup_output(float aspect_ratio) void Machine::setup_output(float aspect_ratio)
{ {
_speaker.reset(new Speaker); speaker_.reset(new Speaker);
_crt.reset(new Outputs::CRT::CRT(crt_cycles_per_line, 8, Outputs::CRT::DisplayType::PAL50, 1)); crt_.reset(new Outputs::CRT::CRT(crt_cycles_per_line, 8, Outputs::CRT::DisplayType::PAL50, 1));
_crt->set_rgb_sampling_function( crt_->set_rgb_sampling_function(
"vec3 rgb_sample(usampler2D sampler, vec2 coordinate, vec2 icoordinate)" "vec3 rgb_sample(usampler2D sampler, vec2 coordinate, vec2 icoordinate)"
"{" "{"
"uint texValue = texture(sampler, coordinate).r;" "uint texValue = texture(sampler, coordinate).r;"
@@ -69,17 +68,17 @@ void Machine::setup_output(float aspect_ratio)
"}"); "}");
// TODO: as implied below, I've introduced a clock's latency into the graphics pipeline somehow. Investigate. // TODO: as implied below, I've introduced a clock's latency into the graphics pipeline somehow. Investigate.
_crt->set_visible_area(_crt->get_rect_for_area(first_graphics_line - 3, 256, (first_graphics_cycle+1) * crt_cycles_multiplier, 80 * crt_cycles_multiplier, 4.0f / 3.0f)); crt_->set_visible_area(crt_->get_rect_for_area(first_graphics_line - 3, 256, (first_graphics_cycle+1) * crt_cycles_multiplier, 80 * crt_cycles_multiplier, 4.0f / 3.0f));
// The maximum output frequency is 62500Hz and all other permitted output frequencies are integral divisions of that; // The maximum output frequency is 62500Hz and all other permitted output frequencies are integral divisions of that;
// however setting the speaker on or off can happen on any 2Mhz cycle, and probably (?) takes effect immediately. So // however setting the speaker on or off can happen on any 2Mhz cycle, and probably (?) takes effect immediately. So
// run the speaker at a 2000000Hz input rate, at least for the time being. // run the speaker at a 2000000Hz input rate, at least for the time being.
_speaker->set_input_rate(2000000 / Speaker::clock_rate_divider); speaker_->set_input_rate(2000000 / Speaker::clock_rate_divider);
} }
void Machine::close_output() void Machine::close_output()
{ {
_crt = nullptr; crt_ = nullptr;
} }
unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uint16_t address, uint8_t *value) unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uint16_t address, uint8_t *value)
@@ -90,29 +89,29 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
{ {
if(isReadOperation(operation)) if(isReadOperation(operation))
{ {
*value = _ram[address]; *value = ram_[address];
} }
else else
{ {
if( if(
( (
((_frameCycles >= first_graphics_line * cycles_per_line) && (_frameCycles < (first_graphics_line + 256) * cycles_per_line)) || ((frame_cycles_ >= first_graphics_line * cycles_per_line) && (frame_cycles_ < (first_graphics_line + 256) * cycles_per_line)) ||
((_frameCycles >= (first_graphics_line + field_divider_line) * cycles_per_line) && (_frameCycles < (first_graphics_line + 256 + field_divider_line) * cycles_per_line)) ((frame_cycles_ >= (first_graphics_line + field_divider_line) * cycles_per_line) && (frame_cycles_ < (first_graphics_line + 256 + field_divider_line) * cycles_per_line))
) )
) )
update_display(); update_display();
_ram[address] = *value; ram_[address] = *value;
} }
// for the entire frame, RAM is accessible only on odd cycles; in modes below 4 // for the entire frame, RAM is accessible only on odd cycles; in modes below 4
// it's also accessible only outside of the pixel regions // it's also accessible only outside of the pixel regions
cycles += 1 + (_frameCycles&1); cycles += 1 + (frame_cycles_&1);
if(_screen_mode < 4) if(screen_mode_ < 4)
{ {
const int current_line = graphics_line(_frameCycles + (_frameCycles&1)); const int current_line = graphics_line(frame_cycles_ + (frame_cycles_&1));
const int current_column = graphics_column(_frameCycles + (_frameCycles&1)); const int current_column = graphics_column(frame_cycles_ + (frame_cycles_&1));
if(current_line < 256 && current_column < 80 && !_isBlankLine) if(current_line < 256 && current_column < 80 && !is_blank_line_)
cycles += (unsigned int)(80 - current_column); cycles += (unsigned int)(80 - current_column);
} }
} }
@@ -127,39 +126,39 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
case 0xfe00: case 0xfe00:
if(isReadOperation(operation)) if(isReadOperation(operation))
{ {
*value = _interrupt_status; *value = interrupt_status_;
_interrupt_status &= ~PowerOnReset; interrupt_status_ &= ~PowerOnReset;
} }
else else
{ {
_interrupt_control = (*value) & ~1; interrupt_control_ = (*value) & ~1;
evaluate_interrupts(); evaluate_interrupts();
} }
break; break;
case 0xfe02: case 0xfe02:
if(!isReadOperation(operation)) if(!isReadOperation(operation))
{ {
_startScreenAddress = (_startScreenAddress & 0xfe00) | (uint16_t)(((*value) & 0xe0) << 1); start_screen_address_ = (start_screen_address_ & 0xfe00) | (uint16_t)(((*value) & 0xe0) << 1);
if(!_startScreenAddress) _startScreenAddress |= 0x8000; if(!start_screen_address_) start_screen_address_ |= 0x8000;
} }
break; break;
case 0xfe03: case 0xfe03:
if(!isReadOperation(operation)) if(!isReadOperation(operation))
{ {
_startScreenAddress = (_startScreenAddress & 0x01ff) | (uint16_t)(((*value) & 0x3f) << 9); start_screen_address_ = (start_screen_address_ & 0x01ff) | (uint16_t)(((*value) & 0x3f) << 9);
if(!_startScreenAddress) _startScreenAddress |= 0x8000; if(!start_screen_address_) start_screen_address_ |= 0x8000;
} }
break; break;
case 0xfe04: case 0xfe04:
if(isReadOperation(operation)) if(isReadOperation(operation))
{ {
*value = _tape.get_data_register(); *value = tape_.get_data_register();
_tape.clear_interrupts(Interrupt::ReceiveDataFull); tape_.clear_interrupts(Interrupt::ReceiveDataFull);
} }
else else
{ {
_tape.set_data_register(*value); tape_.set_data_register(*value);
_tape.clear_interrupts(Interrupt::TransmitDataEmpty); tape_.clear_interrupts(Interrupt::TransmitDataEmpty);
} }
break; break;
case 0xfe05: case 0xfe05:
@@ -168,29 +167,29 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
const uint8_t interruptDisable = (*value)&0xf0; const uint8_t interruptDisable = (*value)&0xf0;
if( interruptDisable ) if( interruptDisable )
{ {
if( interruptDisable&0x10 ) _interrupt_status &= ~Interrupt::DisplayEnd; if( interruptDisable&0x10 ) interrupt_status_ &= ~Interrupt::DisplayEnd;
if( interruptDisable&0x20 ) _interrupt_status &= ~Interrupt::RealTimeClock; if( interruptDisable&0x20 ) interrupt_status_ &= ~Interrupt::RealTimeClock;
if( interruptDisable&0x40 ) _interrupt_status &= ~Interrupt::HighToneDetect; if( interruptDisable&0x40 ) interrupt_status_ &= ~Interrupt::HighToneDetect;
evaluate_interrupts(); evaluate_interrupts();
// TODO: NMI // TODO: NMI
} }
// latch the paged ROM in case external hardware is being emulated // latch the paged ROM in case external hardware is being emulated
_active_rom = (Electron::ROMSlot)(*value & 0xf); active_rom_ = (Electron::ROMSlot)(*value & 0xf);
// apply the ULA's test // apply the ULA's test
if(*value & 0x08) if(*value & 0x08)
{ {
if(*value & 0x04) if(*value & 0x04)
{ {
_keyboard_is_active = false; keyboard_is_active_ = false;
_basic_is_active = false; basic_is_active_ = false;
} }
else else
{ {
_keyboard_is_active = !(*value & 0x02); keyboard_is_active_ = !(*value & 0x02);
_basic_is_active = !_keyboard_is_active; basic_is_active_ = !keyboard_is_active_;
} }
} }
} }
@@ -199,8 +198,8 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
if(!isReadOperation(operation)) if(!isReadOperation(operation))
{ {
update_audio(); update_audio();
_speaker->set_divider(*value); speaker_->set_divider(*value);
_tape.set_counter(*value); tape_.set_counter(*value);
} }
break; break;
case 0xfe07: case 0xfe07:
@@ -209,16 +208,16 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
// update screen mode // update screen mode
uint8_t new_screen_mode = ((*value) >> 3)&7; uint8_t new_screen_mode = ((*value) >> 3)&7;
if(new_screen_mode == 7) new_screen_mode = 4; if(new_screen_mode == 7) new_screen_mode = 4;
if(new_screen_mode != _screen_mode) if(new_screen_mode != screen_mode_)
{ {
update_display(); update_display();
_screen_mode = new_screen_mode; screen_mode_ = new_screen_mode;
switch(_screen_mode) switch(screen_mode_)
{ {
case 0: case 1: case 2: _screenModeBaseAddress = 0x3000; break; case 0: case 1: case 2: screen_mode_base_address_ = 0x3000; break;
case 3: _screenModeBaseAddress = 0x4000; break; case 3: screen_mode_base_address_ = 0x4000; break;
case 4: case 5: _screenModeBaseAddress = 0x5800; break; case 4: case 5: screen_mode_base_address_ = 0x5800; break;
case 6: _screenModeBaseAddress = 0x6000; break; case 6: screen_mode_base_address_ = 0x6000; break;
} }
} }
@@ -227,13 +226,13 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
if(new_speaker_is_enabled != speaker_is_enabled_) if(new_speaker_is_enabled != speaker_is_enabled_)
{ {
update_audio(); update_audio();
_speaker->set_is_enabled(new_speaker_is_enabled); speaker_->set_is_enabled(new_speaker_is_enabled);
speaker_is_enabled_ = new_speaker_is_enabled; speaker_is_enabled_ = new_speaker_is_enabled;
} }
_tape.set_is_enabled((*value & 6) != 6); tape_.set_is_enabled((*value & 6) != 6);
_tape.set_is_in_input_mode((*value & 6) == 0); tape_.set_is_in_input_mode((*value & 6) == 0);
_tape.set_is_running(((*value)&0x40) ? true : false); tape_.set_is_running(((*value)&0x40) ? true : false);
// TODO: caps lock LED // TODO: caps lock LED
} }
@@ -254,46 +253,46 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
const uint8_t colour = ~(*value); const uint8_t colour = ~(*value);
if(address&1) if(address&1)
{ {
_palette[registers[index][0]] = (_palette[registers[index][0]]&3) | ((colour >> 1)&4); palette_[registers[index][0]] = (palette_[registers[index][0]]&3) | ((colour >> 1)&4);
_palette[registers[index][1]] = (_palette[registers[index][1]]&3) | ((colour >> 0)&4); palette_[registers[index][1]] = (palette_[registers[index][1]]&3) | ((colour >> 0)&4);
_palette[registers[index][2]] = (_palette[registers[index][2]]&3) | ((colour << 1)&4); palette_[registers[index][2]] = (palette_[registers[index][2]]&3) | ((colour << 1)&4);
_palette[registers[index][3]] = (_palette[registers[index][3]]&3) | ((colour << 2)&4); palette_[registers[index][3]] = (palette_[registers[index][3]]&3) | ((colour << 2)&4);
_palette[registers[index][2]] = (_palette[registers[index][2]]&5) | ((colour >> 4)&2); palette_[registers[index][2]] = (palette_[registers[index][2]]&5) | ((colour >> 4)&2);
_palette[registers[index][3]] = (_palette[registers[index][3]]&5) | ((colour >> 3)&2); palette_[registers[index][3]] = (palette_[registers[index][3]]&5) | ((colour >> 3)&2);
} }
else else
{ {
_palette[registers[index][0]] = (_palette[registers[index][0]]&6) | ((colour >> 7)&1); palette_[registers[index][0]] = (palette_[registers[index][0]]&6) | ((colour >> 7)&1);
_palette[registers[index][1]] = (_palette[registers[index][1]]&6) | ((colour >> 6)&1); palette_[registers[index][1]] = (palette_[registers[index][1]]&6) | ((colour >> 6)&1);
_palette[registers[index][2]] = (_palette[registers[index][2]]&6) | ((colour >> 5)&1); palette_[registers[index][2]] = (palette_[registers[index][2]]&6) | ((colour >> 5)&1);
_palette[registers[index][3]] = (_palette[registers[index][3]]&6) | ((colour >> 4)&1); palette_[registers[index][3]] = (palette_[registers[index][3]]&6) | ((colour >> 4)&1);
_palette[registers[index][0]] = (_palette[registers[index][0]]&5) | ((colour >> 2)&2); palette_[registers[index][0]] = (palette_[registers[index][0]]&5) | ((colour >> 2)&2);
_palette[registers[index][1]] = (_palette[registers[index][1]]&5) | ((colour >> 1)&2); palette_[registers[index][1]] = (palette_[registers[index][1]]&5) | ((colour >> 1)&2);
} }
// regenerate all palette tables for now // regenerate all palette tables for now
#define pack(a, b) (uint8_t)((a << 4) | (b)) #define pack(a, b) (uint8_t)((a << 4) | (b))
for(int byte = 0; byte < 256; byte++) for(int byte = 0; byte < 256; byte++)
{ {
uint8_t *target = (uint8_t *)&_paletteTables.forty1bpp[byte]; uint8_t *target = (uint8_t *)&palette_tables_.forty1bpp[byte];
target[0] = pack(_palette[(byte&0x80) >> 4], _palette[(byte&0x40) >> 3]); target[0] = pack(palette_[(byte&0x80) >> 4], palette_[(byte&0x40) >> 3]);
target[1] = pack(_palette[(byte&0x20) >> 2], _palette[(byte&0x10) >> 1]); target[1] = pack(palette_[(byte&0x20) >> 2], palette_[(byte&0x10) >> 1]);
target = (uint8_t *)&_paletteTables.eighty2bpp[byte]; target = (uint8_t *)&palette_tables_.eighty2bpp[byte];
target[0] = pack(_palette[((byte&0x80) >> 4) | ((byte&0x08) >> 2)], _palette[((byte&0x40) >> 3) | ((byte&0x04) >> 1)]); target[0] = pack(palette_[((byte&0x80) >> 4) | ((byte&0x08) >> 2)], palette_[((byte&0x40) >> 3) | ((byte&0x04) >> 1)]);
target[1] = pack(_palette[((byte&0x20) >> 2) | ((byte&0x02) >> 0)], _palette[((byte&0x10) >> 1) | ((byte&0x01) << 1)]); target[1] = pack(palette_[((byte&0x20) >> 2) | ((byte&0x02) >> 0)], palette_[((byte&0x10) >> 1) | ((byte&0x01) << 1)]);
target = (uint8_t *)&_paletteTables.eighty1bpp[byte]; target = (uint8_t *)&palette_tables_.eighty1bpp[byte];
target[0] = pack(_palette[(byte&0x80) >> 4], _palette[(byte&0x40) >> 3]); target[0] = pack(palette_[(byte&0x80) >> 4], palette_[(byte&0x40) >> 3]);
target[1] = pack(_palette[(byte&0x20) >> 2], _palette[(byte&0x10) >> 1]); target[1] = pack(palette_[(byte&0x20) >> 2], palette_[(byte&0x10) >> 1]);
target[2] = pack(_palette[(byte&0x08) >> 0], _palette[(byte&0x04) << 1]); target[2] = pack(palette_[(byte&0x08) >> 0], palette_[(byte&0x04) << 1]);
target[3] = pack(_palette[(byte&0x02) << 2], _palette[(byte&0x01) << 3]); target[3] = pack(palette_[(byte&0x02) << 2], palette_[(byte&0x01) << 3]);
_paletteTables.forty2bpp[byte] = pack(_palette[((byte&0x80) >> 4) | ((byte&0x08) >> 2)], _palette[((byte&0x40) >> 3) | ((byte&0x04) >> 1)]); palette_tables_.forty2bpp[byte] = pack(palette_[((byte&0x80) >> 4) | ((byte&0x08) >> 2)], palette_[((byte&0x40) >> 3) | ((byte&0x04) >> 1)]);
_paletteTables.eighty4bpp[byte] = pack( _palette[((byte&0x80) >> 4) | ((byte&0x20) >> 3) | ((byte&0x08) >> 2) | ((byte&0x02) >> 1)], palette_tables_.eighty4bpp[byte] = pack( palette_[((byte&0x80) >> 4) | ((byte&0x20) >> 3) | ((byte&0x08) >> 2) | ((byte&0x02) >> 1)],
_palette[((byte&0x40) >> 3) | ((byte&0x10) >> 2) | ((byte&0x04) >> 1) | ((byte&0x01) >> 0)]); palette_[((byte&0x40) >> 3) | ((byte&0x10) >> 2) | ((byte&0x04) >> 1) | ((byte&0x01) >> 0)]);
} }
#undef pack #undef pack
} }
@@ -301,7 +300,7 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
break; break;
case 0xfc04: case 0xfc05: case 0xfc06: case 0xfc07: case 0xfc04: case 0xfc05: case 0xfc06: case 0xfc07:
if(_plus3 && (address&0x00f0) == 0x00c0) if(plus3_ && (address&0x00f0) == 0x00c0)
{ {
if(is_holding_shift_ && address == 0xfcc4) if(is_holding_shift_ && address == 0xfcc4)
{ {
@@ -309,17 +308,17 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
set_key_state(KeyShift, false); set_key_state(KeyShift, false);
} }
if(isReadOperation(operation)) if(isReadOperation(operation))
*value = _plus3->get_register(address); *value = plus3_->get_register(address);
else else
_plus3->set_register(address, *value); plus3_->set_register(address, *value);
} }
break; break;
case 0xfc00: case 0xfc00:
if(_plus3 && (address&0x00f0) == 0x00c0) if(plus3_ && (address&0x00f0) == 0x00c0)
{ {
if(!isReadOperation(operation)) if(!isReadOperation(operation))
{ {
_plus3->set_control_register(*value); plus3_->set_control_register(*value);
} }
else else
*value = 1; *value = 1;
@@ -332,8 +331,8 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
if(isReadOperation(operation)) if(isReadOperation(operation))
{ {
if( if(
_use_fast_tape_hack && use_fast_tape_hack_ &&
_tape.has_tape() && tape_.has_tape() &&
(operation == CPU6502::BusOperation::ReadOpcode) && (operation == CPU6502::BusOperation::ReadOpcode) &&
( (
(address == 0xf4e5) || (address == 0xf4e6) || // double NOPs at 0xf4e5, 0xf6de, 0xf6fa and 0xfa51 (address == 0xf4e5) || (address == 0xf4e6) || // double NOPs at 0xf4e5, 0xf6de, 0xf6fa and 0xfa51
@@ -355,41 +354,41 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
uint8_t service_call = (uint8_t)get_value_of_register(CPU6502::Register::X); uint8_t service_call = (uint8_t)get_value_of_register(CPU6502::Register::X);
if(address == 0xf0a8) if(address == 0xf0a8)
{ {
if(!_ram[0x247] && service_call == 14) if(!ram_[0x247] && service_call == 14)
{ {
_tape.set_delegate(nullptr); tape_.set_delegate(nullptr);
// TODO: handle tape wrap around. // TODO: handle tape wrap around.
int cycles_left_while_plausibly_in_data = 50; int cycles_left_while_plausibly_in_data = 50;
_tape.clear_interrupts(Interrupt::ReceiveDataFull); tape_.clear_interrupts(Interrupt::ReceiveDataFull);
while(!_tape.get_tape()->is_at_end()) while(!tape_.get_tape()->is_at_end())
{ {
_tape.run_for_input_pulse(); tape_.run_for_input_pulse();
cycles_left_while_plausibly_in_data--; cycles_left_while_plausibly_in_data--;
if(!cycles_left_while_plausibly_in_data) _fast_load_is_in_data = false; if(!cycles_left_while_plausibly_in_data) fast_load_is_in_data_ = false;
if( (_tape.get_interrupt_status() & Interrupt::ReceiveDataFull) && if( (tape_.get_interrupt_status() & Interrupt::ReceiveDataFull) &&
(_fast_load_is_in_data || _tape.get_data_register() == 0x2a) (fast_load_is_in_data_ || tape_.get_data_register() == 0x2a)
) break; ) break;
} }
_tape.set_delegate(this); tape_.set_delegate(this);
_tape.clear_interrupts(Interrupt::ReceiveDataFull); tape_.clear_interrupts(Interrupt::ReceiveDataFull);
_interrupt_status |= _tape.get_interrupt_status(); interrupt_status_ |= tape_.get_interrupt_status();
_fast_load_is_in_data = true; fast_load_is_in_data_ = true;
set_value_of_register(CPU6502::Register::A, 0); set_value_of_register(CPU6502::Register::A, 0);
set_value_of_register(CPU6502::Register::Y, _tape.get_data_register()); set_value_of_register(CPU6502::Register::Y, tape_.get_data_register());
*value = 0x60; // 0x60 is RTS *value = 0x60; // 0x60 is RTS
} }
else else
*value = _os[address & 16383]; *value = os_[address & 16383];
} }
else else
*value = 0xea; *value = 0xea;
} }
else else
{ {
*value = _os[address & 16383]; *value = os_[address & 16383];
} }
} }
} }
@@ -397,22 +396,22 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
{ {
if(isReadOperation(operation)) if(isReadOperation(operation))
{ {
*value = _roms[_active_rom][address & 16383]; *value = roms_[active_rom_][address & 16383];
if(_keyboard_is_active) if(keyboard_is_active_)
{ {
*value &= 0xf0; *value &= 0xf0;
for(int address_line = 0; address_line < 14; address_line++) for(int address_line = 0; address_line < 14; address_line++)
{ {
if(!(address&(1 << address_line))) *value |= _key_states[address_line]; if(!(address&(1 << address_line))) *value |= key_states_[address_line];
} }
} }
if(_basic_is_active) if(basic_is_active_)
{ {
*value &= _roms[ROMSlotBASIC][address & 16383]; *value &= roms_[ROMSlotBASIC][address & 16383];
} }
} else if(_rom_write_masks[_active_rom]) } else if(rom_write_masks_[active_rom_])
{ {
_roms[_active_rom][address & 16383] = *value; roms_[active_rom_][address & 16383] = *value;
} }
} }
break; break;
@@ -425,9 +424,9 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
// } // }
// const int end_of_field = // const int end_of_field =
// if(_frameCycles < (256 + first_graphics_line) << 7)) // if(frame_cycles_ < (256 + first_graphics_line) << 7))
const unsigned int pixel_line_clock = _frameCycles;// + 128 - first_graphics_cycle + 80; const unsigned int pixel_line_clock = frame_cycles_;// + 128 - first_graphics_cycle + 80;
const unsigned int line_before_cycle = graphics_line(pixel_line_clock); const unsigned int line_before_cycle = graphics_line(pixel_line_clock);
const unsigned int line_after_cycle = graphics_line(pixel_line_clock + cycles); const unsigned int line_after_cycle = graphics_line(pixel_line_clock + cycles);
@@ -451,30 +450,30 @@ unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uin
signal_interrupt(Interrupt::RealTimeClock); signal_interrupt(Interrupt::RealTimeClock);
} }
_frameCycles += cycles; frame_cycles_ += cycles;
if(!(_frameCycles&127)) _phase += 64; if(!(frame_cycles_&127)) phase_ += 64;
// deal with frame wraparound by updating the two dependent subsystems // deal with frame wraparound by updating the two dependent subsystems
// as though the exact end of frame had been hit, then reset those // as though the exact end of frame had been hit, then reset those
// and allow the frame cycle counter to assume its real value // and allow the frame cycle counter to assume its real value
if(_frameCycles >= cycles_per_frame) if(frame_cycles_ >= cycles_per_frame)
{ {
unsigned int nextFrameCycles = _frameCycles - cycles_per_frame; unsigned int nextFrameCycles = frame_cycles_ - cycles_per_frame;
_frameCycles = cycles_per_frame; frame_cycles_ = cycles_per_frame;
update_display(); update_display();
update_audio(); update_audio();
_displayOutputPosition = 0; display_output_position_ = 0;
_audioOutputPosition = 0; audio_output_position_ = 0;
_frameCycles = nextFrameCycles; frame_cycles_ = nextFrameCycles;
} }
if(!(_frameCycles&16383)) if(!(frame_cycles_&16383))
update_audio(); update_audio();
_tape.run_for_cycles(cycles); tape_.run_for_cycles(cycles);
if(typer_) typer_->update((int)cycles); if(typer_) typer_->update((int)cycles);
if(_plus3) _plus3->run_for_cycles(4*cycles); if(plus3_) plus3_->run_for_cycles(4*cycles);
return cycles; return cycles;
} }
@@ -483,31 +482,31 @@ void Machine::synchronise()
{ {
update_display(); update_display();
update_audio(); update_audio();
_speaker->flush(); speaker_->flush();
} }
void Machine::configure_as_target(const StaticAnalyser::Target &target) void Machine::configure_as_target(const StaticAnalyser::Target &target)
{ {
if(target.tapes.size()) if(target.tapes.size())
{ {
_tape.set_tape(target.tapes.front()); tape_.set_tape(target.tapes.front());
} }
if(target.disks.size()) if(target.disks.size())
{ {
_plus3.reset(new Plus3); plus3_.reset(new Plus3);
if(target.acorn.has_dfs) if(target.acorn.has_dfs)
{ {
set_rom(ROMSlot0, _dfs, true); set_rom(ROMSlot0, dfs_, true);
} }
if(target.acorn.has_adfs) if(target.acorn.has_adfs)
{ {
set_rom(ROMSlot4, _adfs, true); set_rom(ROMSlot4, adfs_, true);
set_rom(ROMSlot5, std::vector<uint8_t>(_adfs.begin() + 16384, _adfs.end()), true); set_rom(ROMSlot5, std::vector<uint8_t>(adfs_.begin() + 16384, adfs_.end()), true);
} }
_plus3->set_disk(target.disks.front(), 0); plus3_->set_disk(target.disks.front(), 0);
} }
ROMSlot slot = ROMSlot12; ROMSlot slot = ROMSlot12;
@@ -533,13 +532,13 @@ void Machine::set_rom(ROMSlot slot, std::vector<uint8_t> data, bool is_writeable
uint8_t *target = nullptr; uint8_t *target = nullptr;
switch(slot) switch(slot)
{ {
case ROMSlotDFS: _dfs = data; return; case ROMSlotDFS: dfs_ = data; return;
case ROMSlotADFS: _adfs = data; return; case ROMSlotADFS: adfs_ = data; return;
case ROMSlotOS: target = _os; break; case ROMSlotOS: target = os_; break;
default: default:
target = _roms[slot]; target = roms_[slot];
_rom_write_masks[slot] = is_writeable; rom_write_masks_[slot] = is_writeable;
break; break;
} }
@@ -548,221 +547,221 @@ void Machine::set_rom(ROMSlot slot, std::vector<uint8_t> data, bool is_writeable
inline void Machine::signal_interrupt(Electron::Interrupt interrupt) inline void Machine::signal_interrupt(Electron::Interrupt interrupt)
{ {
_interrupt_status |= interrupt; interrupt_status_ |= interrupt;
evaluate_interrupts(); evaluate_interrupts();
} }
inline void Machine::clear_interrupt(Electron::Interrupt interrupt) inline void Machine::clear_interrupt(Electron::Interrupt interrupt)
{ {
_interrupt_status &= ~interrupt; interrupt_status_ &= ~interrupt;
evaluate_interrupts(); evaluate_interrupts();
} }
void Machine::tape_did_change_interrupt_status(Tape *tape) void Machine::tape_did_change_interrupt_status(Tape *tape)
{ {
_interrupt_status = (_interrupt_status & ~(Interrupt::TransmitDataEmpty | Interrupt::ReceiveDataFull | Interrupt::HighToneDetect)) | _tape.get_interrupt_status(); interrupt_status_ = (interrupt_status_ & ~(Interrupt::TransmitDataEmpty | Interrupt::ReceiveDataFull | Interrupt::HighToneDetect)) | tape_.get_interrupt_status();
evaluate_interrupts(); evaluate_interrupts();
} }
inline void Machine::evaluate_interrupts() inline void Machine::evaluate_interrupts()
{ {
if(_interrupt_status & _interrupt_control) if(interrupt_status_ & interrupt_control_)
{ {
_interrupt_status |= 1; interrupt_status_ |= 1;
} }
else else
{ {
_interrupt_status &= ~1; interrupt_status_ &= ~1;
} }
set_irq_line(_interrupt_status & 1); set_irq_line(interrupt_status_ & 1);
} }
inline void Machine::update_audio() inline void Machine::update_audio()
{ {
unsigned int difference = _frameCycles - _audioOutputPosition; unsigned int difference = frame_cycles_ - audio_output_position_ + audio_output_position_error_;
_audioOutputPosition = _frameCycles; audio_output_position_ = frame_cycles_;
_speaker->run_for_cycles(difference / Speaker::clock_rate_divider); speaker_->run_for_cycles(difference / Speaker::clock_rate_divider);
_audioOutputPositionError = difference % Speaker::clock_rate_divider; audio_output_position_error_ = difference % Speaker::clock_rate_divider;
} }
inline void Machine::start_pixel_line() inline void Machine::start_pixel_line()
{ {
_current_pixel_line = (_current_pixel_line+1)&255; current_pixel_line_ = (current_pixel_line_+1)&255;
if(!_current_pixel_line) if(!current_pixel_line_)
{ {
_startLineAddress = _startScreenAddress; start_line_address_ = start_screen_address_;
_current_character_row = 0; current_character_row_ = 0;
_isBlankLine = false; is_blank_line_ = false;
} }
else else
{ {
bool mode_has_blank_lines = (_screen_mode == 6) || (_screen_mode == 3); bool mode_has_blank_lines = (screen_mode_ == 6) || (screen_mode_ == 3);
_isBlankLine = (mode_has_blank_lines && ((_current_character_row > 7 && _current_character_row < 10) || (_current_pixel_line > 249))); is_blank_line_ = (mode_has_blank_lines && ((current_character_row_ > 7 && current_character_row_ < 10) || (current_pixel_line_ > 249)));
if(!_isBlankLine) if(!is_blank_line_)
{ {
_startLineAddress++; start_line_address_++;
if(_current_character_row > 7) if(current_character_row_ > 7)
{ {
_startLineAddress += ((_screen_mode < 4) ? 80 : 40) * 8 - 8; start_line_address_ += ((screen_mode_ < 4) ? 80 : 40) * 8 - 8;
_current_character_row = 0; current_character_row_ = 0;
} }
} }
} }
_currentScreenAddress = _startLineAddress; current_screen_address_ = start_line_address_;
_current_pixel_column = 0; current_pixel_column_ = 0;
_initial_output_target = _current_output_target = nullptr; initial_output_target_ = current_output_target_ = nullptr;
} }
inline void Machine::end_pixel_line() inline void Machine::end_pixel_line()
{ {
if(_current_output_target) _crt->output_data((unsigned int)((_current_output_target - _initial_output_target) * _current_output_divider), _current_output_divider); if(current_output_target_) crt_->output_data((unsigned int)((current_output_target_ - initial_output_target_) * current_output_divider_), current_output_divider_);
_current_character_row++; current_character_row_++;
} }
inline void Machine::output_pixels(unsigned int number_of_cycles) inline void Machine::output_pixels(unsigned int number_of_cycles)
{ {
if(!number_of_cycles) return; if(!number_of_cycles) return;
if(_isBlankLine) if(is_blank_line_)
{ {
_crt->output_blank(number_of_cycles * crt_cycles_multiplier); crt_->output_blank(number_of_cycles * crt_cycles_multiplier);
} }
else else
{ {
unsigned int divider = 0; unsigned int divider = 0;
switch(_screen_mode) switch(screen_mode_)
{ {
case 0: case 3: divider = 2; break; case 0: case 3: divider = 2; break;
case 1: case 4: case 6: divider = 4; break; case 1: case 4: case 6: divider = 4; break;
case 2: case 5: divider = 8; break; case 2: case 5: divider = 8; break;
} }
if(!_initial_output_target || divider != _current_output_divider) if(!initial_output_target_ || divider != current_output_divider_)
{ {
if(_current_output_target) _crt->output_data((unsigned int)((_current_output_target - _initial_output_target) * _current_output_divider), _current_output_divider); if(current_output_target_) crt_->output_data((unsigned int)((current_output_target_ - initial_output_target_) * current_output_divider_), current_output_divider_);
_current_output_divider = divider; current_output_divider_ = divider;
_initial_output_target = _current_output_target = _crt->allocate_write_area(640 / _current_output_divider); initial_output_target_ = current_output_target_ = crt_->allocate_write_area(640 / current_output_divider_);
} }
#define get_pixel() \ #define get_pixel() \
if(_currentScreenAddress&32768)\ if(current_screen_address_&32768)\
{\ {\
_currentScreenAddress = (_screenModeBaseAddress + _currentScreenAddress)&32767;\ current_screen_address_ = (screen_mode_base_address_ + current_screen_address_)&32767;\
}\ }\
_last_pixel_byte = _ram[_currentScreenAddress];\ last_pixel_byte_ = ram_[current_screen_address_];\
_currentScreenAddress = _currentScreenAddress+8 current_screen_address_ = current_screen_address_+8
switch(_screen_mode) switch(screen_mode_)
{ {
case 0: case 3: case 0: case 3:
if(_initial_output_target) if(initial_output_target_)
{ {
while(number_of_cycles--) while(number_of_cycles--)
{ {
get_pixel(); get_pixel();
*(uint32_t *)_current_output_target = _paletteTables.eighty1bpp[_last_pixel_byte]; *(uint32_t *)current_output_target_ = palette_tables_.eighty1bpp[last_pixel_byte_];
_current_output_target += 4; current_output_target_ += 4;
_current_pixel_column++; current_pixel_column_++;
} }
} else _current_output_target += 4*number_of_cycles; } else current_output_target_ += 4*number_of_cycles;
break; break;
case 1: case 1:
if(_initial_output_target) if(initial_output_target_)
{ {
while(number_of_cycles--) while(number_of_cycles--)
{ {
get_pixel(); get_pixel();
*(uint16_t *)_current_output_target = _paletteTables.eighty2bpp[_last_pixel_byte]; *(uint16_t *)current_output_target_ = palette_tables_.eighty2bpp[last_pixel_byte_];
_current_output_target += 2; current_output_target_ += 2;
_current_pixel_column++; current_pixel_column_++;
} }
} else _current_output_target += 2*number_of_cycles; } else current_output_target_ += 2*number_of_cycles;
break; break;
case 2: case 2:
if(_initial_output_target) if(initial_output_target_)
{ {
while(number_of_cycles--) while(number_of_cycles--)
{ {
get_pixel(); get_pixel();
*_current_output_target = _paletteTables.eighty4bpp[_last_pixel_byte]; *current_output_target_ = palette_tables_.eighty4bpp[last_pixel_byte_];
_current_output_target += 1; current_output_target_ += 1;
_current_pixel_column++; current_pixel_column_++;
} }
} else _current_output_target += number_of_cycles; } else current_output_target_ += number_of_cycles;
break; break;
case 4: case 6: case 4: case 6:
if(_initial_output_target) if(initial_output_target_)
{ {
if(_current_pixel_column&1) if(current_pixel_column_&1)
{ {
_last_pixel_byte <<= 4; last_pixel_byte_ <<= 4;
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte]; *(uint16_t *)current_output_target_ = palette_tables_.forty1bpp[last_pixel_byte_];
_current_output_target += 2; current_output_target_ += 2;
number_of_cycles--; number_of_cycles--;
_current_pixel_column++; current_pixel_column_++;
} }
while(number_of_cycles > 1) while(number_of_cycles > 1)
{ {
get_pixel(); get_pixel();
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte]; *(uint16_t *)current_output_target_ = palette_tables_.forty1bpp[last_pixel_byte_];
_current_output_target += 2; current_output_target_ += 2;
_last_pixel_byte <<= 4; last_pixel_byte_ <<= 4;
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte]; *(uint16_t *)current_output_target_ = palette_tables_.forty1bpp[last_pixel_byte_];
_current_output_target += 2; current_output_target_ += 2;
number_of_cycles -= 2; number_of_cycles -= 2;
_current_pixel_column+=2; current_pixel_column_+=2;
} }
if(number_of_cycles) if(number_of_cycles)
{ {
get_pixel(); get_pixel();
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte]; *(uint16_t *)current_output_target_ = palette_tables_.forty1bpp[last_pixel_byte_];
_current_output_target += 2; current_output_target_ += 2;
_current_pixel_column++; current_pixel_column_++;
} }
} else _current_output_target += 2 * number_of_cycles; } else current_output_target_ += 2 * number_of_cycles;
break; break;
case 5: case 5:
if(_initial_output_target) if(initial_output_target_)
{ {
if(_current_pixel_column&1) if(current_pixel_column_&1)
{ {
_last_pixel_byte <<= 2; last_pixel_byte_ <<= 2;
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte]; *current_output_target_ = palette_tables_.forty2bpp[last_pixel_byte_];
_current_output_target += 1; current_output_target_ += 1;
number_of_cycles--; number_of_cycles--;
_current_pixel_column++; current_pixel_column_++;
} }
while(number_of_cycles > 1) while(number_of_cycles > 1)
{ {
get_pixel(); get_pixel();
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte]; *current_output_target_ = palette_tables_.forty2bpp[last_pixel_byte_];
_current_output_target += 1; current_output_target_ += 1;
_last_pixel_byte <<= 2; last_pixel_byte_ <<= 2;
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte]; *current_output_target_ = palette_tables_.forty2bpp[last_pixel_byte_];
_current_output_target += 1; current_output_target_ += 1;
number_of_cycles -= 2; number_of_cycles -= 2;
_current_pixel_column+=2; current_pixel_column_+=2;
} }
if(number_of_cycles) if(number_of_cycles)
{ {
get_pixel(); get_pixel();
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte]; *current_output_target_ = palette_tables_.forty2bpp[last_pixel_byte_];
_current_output_target += 1; current_output_target_ += 1;
_current_pixel_column++; current_pixel_column_++;
} }
} else _current_output_target += number_of_cycles; } else current_output_target_ += number_of_cycles;
break; break;
} }
@@ -786,10 +785,10 @@ inline void Machine::update_display()
*/ */
int final_line = _frameCycles >> 7; int final_line = frame_cycles_ >> 7;
while(_displayOutputPosition < _frameCycles) while(display_output_position_ < frame_cycles_)
{ {
int line = _displayOutputPosition >> 7; int line = display_output_position_ >> 7;
// Priority one: sync. // Priority one: sync.
// =================== // ===================
@@ -799,8 +798,8 @@ inline void Machine::update_display()
{ {
// wait for the line to complete before signalling // wait for the line to complete before signalling
if(final_line == line) return; if(final_line == line) return;
_crt->output_sync(128 * crt_cycles_multiplier); crt_->output_sync(128 * crt_cycles_multiplier);
_displayOutputPosition += 128; display_output_position_ += 128;
continue; continue;
} }
@@ -809,9 +808,9 @@ inline void Machine::update_display()
{ {
// wait for the line to complete before signalling // wait for the line to complete before signalling
if(final_line == line) return; if(final_line == line) return;
_crt->output_sync(64 * crt_cycles_multiplier); crt_->output_sync(64 * crt_cycles_multiplier);
_crt->output_blank(64 * crt_cycles_multiplier); crt_->output_blank(64 * crt_cycles_multiplier);
_displayOutputPosition += 128; display_output_position_ += 128;
continue; continue;
} }
@@ -820,10 +819,10 @@ inline void Machine::update_display()
{ {
// wait for the line to complete before signalling // wait for the line to complete before signalling
if(final_line == line) return; if(final_line == line) return;
_crt->output_sync(9 * crt_cycles_multiplier); crt_->output_sync(9 * crt_cycles_multiplier);
_crt->output_blank(55 * crt_cycles_multiplier); crt_->output_blank(55 * crt_cycles_multiplier);
_crt->output_sync(64 * crt_cycles_multiplier); crt_->output_sync(64 * crt_cycles_multiplier);
_displayOutputPosition += 128; display_output_position_ += 128;
continue; continue;
} }
@@ -839,9 +838,9 @@ inline void Machine::update_display()
line > first_graphics_line+field_divider_line+255) line > first_graphics_line+field_divider_line+255)
{ {
if(final_line == line) return; if(final_line == line) return;
_crt->output_sync(9 * crt_cycles_multiplier); crt_->output_sync(9 * crt_cycles_multiplier);
_crt->output_blank(119 * crt_cycles_multiplier); crt_->output_blank(119 * crt_cycles_multiplier);
_displayOutputPosition += 128; display_output_position_ += 128;
continue; continue;
} }
@@ -849,8 +848,8 @@ inline void Machine::update_display()
// ======================================== // ========================================
// determine how far we're going from left to right // determine how far we're going from left to right
unsigned int this_cycle = _displayOutputPosition&127; unsigned int this_cycle = display_output_position_&127;
unsigned int final_cycle = _frameCycles&127; unsigned int final_cycle = frame_cycles_&127;
if(final_line > line) if(final_line > line)
{ {
final_cycle = 128; final_cycle = 128;
@@ -867,16 +866,16 @@ inline void Machine::update_display()
if(this_cycle < 9) if(this_cycle < 9)
{ {
if(final_cycle < 9) return; if(final_cycle < 9) return;
_crt->output_sync(9 * crt_cycles_multiplier); crt_->output_sync(9 * crt_cycles_multiplier);
_displayOutputPosition += 9; display_output_position_ += 9;
this_cycle = 9; this_cycle = 9;
} }
if(this_cycle < 24) if(this_cycle < 24)
{ {
if(final_cycle < 24) return; if(final_cycle < 24) return;
_crt->output_colour_burst((24-9) * crt_cycles_multiplier, _phase, 12); crt_->output_colour_burst((24-9) * crt_cycles_multiplier, phase_, 12);
_displayOutputPosition += 24-9; display_output_position_ += 24-9;
this_cycle = 24; this_cycle = 24;
// TODO: phase shouldn't be zero on every line // TODO: phase shouldn't be zero on every line
} }
@@ -884,8 +883,8 @@ inline void Machine::update_display()
if(this_cycle < first_graphics_cycle) if(this_cycle < first_graphics_cycle)
{ {
if(final_cycle < first_graphics_cycle) return; if(final_cycle < first_graphics_cycle) return;
_crt->output_blank((first_graphics_cycle - 24) * crt_cycles_multiplier); crt_->output_blank((first_graphics_cycle - 24) * crt_cycles_multiplier);
_displayOutputPosition += first_graphics_cycle - 24; display_output_position_ += first_graphics_cycle - 24;
this_cycle = first_graphics_cycle; this_cycle = first_graphics_cycle;
start_pixel_line(); start_pixel_line();
} }
@@ -894,7 +893,7 @@ inline void Machine::update_display()
{ {
unsigned int length_to_output = std::min(final_cycle, (first_graphics_cycle + 80)) - this_cycle; unsigned int length_to_output = std::min(final_cycle, (first_graphics_cycle + 80)) - this_cycle;
output_pixels(length_to_output); output_pixels(length_to_output);
_displayOutputPosition += length_to_output; display_output_position_ += length_to_output;
this_cycle += length_to_output; this_cycle += length_to_output;
} }
@@ -902,8 +901,8 @@ inline void Machine::update_display()
{ {
if(final_cycle < 128) return; if(final_cycle < 128) return;
end_pixel_line(); end_pixel_line();
_crt->output_blank((128 - (first_graphics_cycle + 80)) * crt_cycles_multiplier); crt_->output_blank((128 - (first_graphics_cycle + 80)) * crt_cycles_multiplier);
_displayOutputPosition += 128 - (first_graphics_cycle + 80); display_output_position_ += 128 - (first_graphics_cycle + 80);
this_cycle = 128; this_cycle = 128;
} }
} }
@@ -912,7 +911,7 @@ inline void Machine::update_display()
void Machine::clear_all_keys() void Machine::clear_all_keys()
{ {
memset(_key_states, 0, sizeof(_key_states)); memset(key_states_, 0, sizeof(key_states_));
} }
void Machine::set_key_state(uint16_t key, bool isPressed) void Machine::set_key_state(uint16_t key, bool isPressed)
@@ -924,8 +923,8 @@ void Machine::set_key_state(uint16_t key, bool isPressed)
else else
{ {
if(isPressed) if(isPressed)
_key_states[key >> 4] |= key&0xf; key_states_[key >> 4] |= key&0xf;
else else
_key_states[key >> 4] &= ~(key&0xf); key_states_[key >> 4] &= ~(key&0xf);
} }
} }

62
Machines/Electron/Electron.hpp
View File

@@ -80,7 +80,7 @@ class Machine:
void set_key_state(uint16_t key, bool isPressed); void set_key_state(uint16_t key, bool isPressed);
void clear_all_keys(); void clear_all_keys();
inline void set_use_fast_tape_hack(bool activate) { _use_fast_tape_hack = activate; } inline void set_use_fast_tape_hack(bool activate) { use_fast_tape_hack_ = activate; }
// to satisfy ConfigurationTarget::Machine // to satisfy ConfigurationTarget::Machine
void configure_as_target(const StaticAnalyser::Target &target); void configure_as_target(const StaticAnalyser::Target &target);
@@ -92,8 +92,8 @@ class Machine:
// to satisfy CRTMachine::Machine // to satisfy CRTMachine::Machine
virtual void setup_output(float aspect_ratio); virtual void setup_output(float aspect_ratio);
virtual void close_output(); virtual void close_output();
virtual std::shared_ptr<Outputs::CRT::CRT> get_crt() { return _crt; } virtual std::shared_ptr<Outputs::CRT::CRT> get_crt() { return crt_; }
virtual std::shared_ptr<Outputs::Speaker> get_speaker() { return _speaker; } virtual std::shared_ptr<Outputs::Speaker> get_speaker() { return speaker_; }
virtual void run_for_cycles(int number_of_cycles) { CPU6502::Processor<Machine>::run_for_cycles(number_of_cycles); } virtual void run_for_cycles(int number_of_cycles) { CPU6502::Processor<Machine>::run_for_cycles(number_of_cycles); }
// to satisfy Tape::Delegate // to satisfy Tape::Delegate
@@ -117,25 +117,25 @@ class Machine:
inline void evaluate_interrupts(); inline void evaluate_interrupts();
// Things that directly constitute the memory map. // Things that directly constitute the memory map.
uint8_t _roms[16][16384]; uint8_t roms_[16][16384];
bool _rom_write_masks[16]; bool rom_write_masks_[16];
uint8_t _os[16384], _ram[32768]; uint8_t os_[16384], ram_[32768];
std::vector<uint8_t> _dfs, _adfs; std::vector<uint8_t> dfs_, adfs_;
// Things affected by registers, explicitly or otherwise. // Things affected by registers, explicitly or otherwise.
uint8_t _interrupt_status, _interrupt_control; uint8_t interrupt_status_, interrupt_control_;
uint8_t _palette[16]; uint8_t palette_[16];
uint8_t _key_states[14]; uint8_t key_states_[14];
ROMSlot _active_rom; ROMSlot active_rom_;
bool _keyboard_is_active, _basic_is_active; bool keyboard_is_active_, basic_is_active_;
uint8_t _screen_mode; uint8_t screen_mode_;
uint16_t _screenModeBaseAddress; uint16_t screen_mode_base_address_;
uint16_t _startScreenAddress; uint16_t start_screen_address_;
// Counters related to simultaneous subsystems // Counters related to simultaneous subsystems
unsigned int _frameCycles, _displayOutputPosition; unsigned int frame_cycles_, display_output_position_;
unsigned int _audioOutputPosition, _audioOutputPositionError; unsigned int audio_output_position_, audio_output_position_error_;
uint8_t _phase; uint8_t phase_;
struct { struct {
uint16_t forty1bpp[256]; uint16_t forty1bpp[256];
@@ -143,30 +143,30 @@ class Machine:
uint32_t eighty1bpp[256]; uint32_t eighty1bpp[256];
uint16_t eighty2bpp[256]; uint16_t eighty2bpp[256];
uint8_t eighty4bpp[256]; uint8_t eighty4bpp[256];
} _paletteTables; } palette_tables_;
// Display generation. // Display generation.
uint16_t _startLineAddress, _currentScreenAddress; uint16_t start_line_address_, current_screen_address_;
int _current_pixel_line, _current_pixel_column, _current_character_row; int current_pixel_line_, current_pixel_column_, current_character_row_;
uint8_t _last_pixel_byte; uint8_t last_pixel_byte_;
bool _isBlankLine; bool is_blank_line_;
// CRT output // CRT output
uint8_t *_current_output_target, *_initial_output_target; uint8_t *current_output_target_, *initial_output_target_;
unsigned int _current_output_divider; unsigned int current_output_divider_;
// Tape // Tape
Tape _tape; Tape tape_;
bool _use_fast_tape_hack; bool use_fast_tape_hack_;
bool _fast_load_is_in_data; bool fast_load_is_in_data_;
// Disk // Disk
std::unique_ptr<Plus3> _plus3; std::unique_ptr<Plus3> plus3_;
bool is_holding_shift_; bool is_holding_shift_;
// Outputs // Outputs
std::shared_ptr<Outputs::CRT::CRT> _crt; std::shared_ptr<Outputs::CRT::CRT> crt_;
std::shared_ptr<Speaker> _speaker; std::shared_ptr<Speaker> speaker_;
bool speaker_is_enabled_; bool speaker_is_enabled_;
}; };