From 3229502fa10db2ae14049536952c691ceea680e4 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Thu, 23 Mar 2017 21:59:16 -0400 Subject: [PATCH] Standardised curly bracket placement across the Atari. --- Machines/Atari2600/Atari2600.hpp | 3 +- Machines/Atari2600/PIA.hpp | 6 +- Machines/Atari2600/Speaker.cpp | 42 ++--- Machines/Atari2600/TIA.cpp | 301 ++++++++++--------------------- Machines/Atari2600/TIA.hpp | 66 +++---- 5 files changed, 136 insertions(+), 282 deletions(-) diff --git a/Machines/Atari2600/Atari2600.hpp b/Machines/Atari2600/Atari2600.hpp index f5055b30c..9147e3f95 100644 --- a/Machines/Atari2600/Atari2600.hpp +++ b/Machines/Atari2600/Atari2600.hpp @@ -57,8 +57,7 @@ class Machine: std::unique_ptr bus_; // output frame rate tracker - struct FrameRecord - { + struct FrameRecord { unsigned int number_of_frames; unsigned int number_of_unexpected_vertical_syncs; diff --git a/Machines/Atari2600/PIA.hpp b/Machines/Atari2600/PIA.hpp index 2faa80242..afd0603aa 100644 --- a/Machines/Atari2600/PIA.hpp +++ b/Machines/Atari2600/PIA.hpp @@ -15,13 +15,11 @@ namespace Atari2600 { class PIA: public MOS::MOS6532 { public: - inline uint8_t get_port_input(int port) - { + inline uint8_t get_port_input(int port) { return port_values_[port]; } - inline void update_port_input(int port, uint8_t mask, bool set) - { + inline void update_port_input(int port, uint8_t mask, bool set) { if(set) port_values_[port] &= ~mask; else port_values_[port] |= mask; set_port_did_change(port); } diff --git a/Machines/Atari2600/Speaker.cpp b/Machines/Atari2600/Speaker.cpp index a304fa29b..86c27c02f 100644 --- a/Machines/Atari2600/Speaker.cpp +++ b/Machines/Atari2600/Speaker.cpp @@ -16,23 +16,20 @@ Atari2600::Speaker::Speaker() : poly9_counter_{0x1ff, 0x1ff} {} -void Atari2600::Speaker::set_volume(int channel, uint8_t volume) -{ +void Atari2600::Speaker::set_volume(int channel, uint8_t volume) { enqueue([=]() { volume_[channel] = volume & 0xf; }); } -void Atari2600::Speaker::set_divider(int channel, uint8_t divider) -{ +void Atari2600::Speaker::set_divider(int channel, uint8_t divider) { enqueue([=]() { divider_[channel] = divider & 0x1f; divider_counter_[channel] = 0; }); } -void Atari2600::Speaker::set_control(int channel, uint8_t control) -{ +void Atari2600::Speaker::set_control(int channel, uint8_t control) { enqueue([=]() { control_[channel] = control & 0xf; }); @@ -42,17 +39,13 @@ void Atari2600::Speaker::set_control(int channel, uint8_t control) #define advance_poly5(c) poly5_counter_[channel] = (poly5_counter_[channel] >> 1) | (((poly5_counter_[channel] << 4) ^ (poly5_counter_[channel] << 2))&0x010) #define advance_poly9(c) poly9_counter_[channel] = (poly9_counter_[channel] >> 1) | (((poly9_counter_[channel] << 4) ^ (poly9_counter_[channel] << 8))&0x100) -void Atari2600::Speaker::get_samples(unsigned int number_of_samples, int16_t *target) -{ - for(unsigned int c = 0; c < number_of_samples; c++) - { +void Atari2600::Speaker::get_samples(unsigned int number_of_samples, int16_t *target) { + for(unsigned int c = 0; c < number_of_samples; c++) { target[c] = 0; - for(int channel = 0; channel < 2; channel++) - { + for(int channel = 0; channel < 2; channel++) { divider_counter_[channel] ++; int level = 0; - switch(control_[channel]) - { + switch(control_[channel]) { case 0x0: case 0xb: // constant 1 level = 1; break; @@ -75,8 +68,7 @@ void Atari2600::Speaker::get_samples(unsigned int number_of_samples, int16_t *ta case 0x1: // 4-bit poly level = poly4_counter_[channel]&1; - if(divider_counter_[channel] == divider_[channel]+1) - { + if(divider_counter_[channel] == divider_[channel]+1) { divider_counter_[channel] = 0; advance_poly4(channel); } @@ -84,18 +76,15 @@ void Atari2600::Speaker::get_samples(unsigned int number_of_samples, int16_t *ta case 0x2: // 4-bit poly div31 level = poly4_counter_[channel]&1; - if(divider_counter_[channel]%(30*(divider_[channel]+1)) == 18) - { + if(divider_counter_[channel]%(30*(divider_[channel]+1)) == 18) { advance_poly4(channel); } break; case 0x3: // 5/4-bit poly level = output_state_[channel]; - if(divider_counter_[channel] == divider_[channel]+1) - { - if(poly5_counter_[channel]&1) - { + if(divider_counter_[channel] == divider_[channel]+1) { + if(poly5_counter_[channel]&1) { output_state_[channel] = poly4_counter_[channel]&1; advance_poly4(channel); } @@ -105,8 +94,7 @@ void Atari2600::Speaker::get_samples(unsigned int number_of_samples, int16_t *ta case 0x7: case 0x9: // 5-bit poly level = poly5_counter_[channel]&1; - if(divider_counter_[channel] == divider_[channel]+1) - { + if(divider_counter_[channel] == divider_[channel]+1) { divider_counter_[channel] = 0; advance_poly5(channel); } @@ -114,8 +102,7 @@ void Atari2600::Speaker::get_samples(unsigned int number_of_samples, int16_t *ta case 0xf: // 5-bit poly div6 level = poly5_counter_[channel]&1; - if(divider_counter_[channel] == (divider_[channel]+1)*3) - { + if(divider_counter_[channel] == (divider_[channel]+1)*3) { divider_counter_[channel] = 0; advance_poly5(channel); } @@ -123,8 +110,7 @@ void Atari2600::Speaker::get_samples(unsigned int number_of_samples, int16_t *ta case 0x8: // 9-bit poly level = poly9_counter_[channel]&1; - if(divider_counter_[channel] == divider_[channel]+1) - { + if(divider_counter_[channel] == divider_[channel]+1) { divider_counter_[channel] = 0; advance_poly9(channel); } diff --git a/Machines/Atari2600/TIA.cpp b/Machines/Atari2600/TIA.cpp index 0b6349676..d43d3e403 100644 --- a/Machines/Atari2600/TIA.cpp +++ b/Machines/Atari2600/TIA.cpp @@ -30,23 +30,20 @@ TIA::TIA(bool create_crt) : horizontal_blank_extend_(false), collision_flags_(0) { - if(create_crt) - { + if(create_crt) { crt_.reset(new Outputs::CRT::CRT(cycles_per_line * 2 - 1, 1, Outputs::CRT::DisplayType::NTSC60, 1)); crt_->set_output_device(Outputs::CRT::Television); set_output_mode(OutputMode::NTSC); } - for(int c = 0; c < 256; c++) - { + for(int c = 0; c < 256; c++) { reverse_table[c] = (uint8_t)( ((c & 0x01) << 7) | ((c & 0x02) << 5) | ((c & 0x04) << 3) | ((c & 0x08) << 1) | ((c & 0x10) >> 1) | ((c & 0x20) >> 3) | ((c & 0x40) >> 5) | ((c & 0x80) >> 7) ); } - for(int c = 0; c < 64; c++) - { + for(int c = 0; c < 64; c++) { bool has_playfield = c & (int)(CollisionType::Playfield); bool has_ball = c & (int)(CollisionType::Ball); bool has_player0 = c & (int)(CollisionType::Player0); @@ -80,21 +77,18 @@ TIA::TIA(bool create_crt) : colour_mask_by_mode_collision_flags_[(int)ColourMode::OnTop][c] = (uint8_t)ColourIndex::Background; // test 1 for standard priority: if there is a playfield or ball pixel, plot that colour - if(has_playfield || has_ball) - { + if(has_playfield || has_ball) { colour_mask_by_mode_collision_flags_[(int)ColourMode::Standard][c] = (uint8_t)ColourIndex::PlayfieldBall; } // test 1 for score mode: if there is a ball pixel, plot that colour - if(has_ball) - { + if(has_ball) { colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] = colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] = (uint8_t)ColourIndex::PlayfieldBall; } // test 1 for on-top mode, test 2 for everbody else: if there is a player 1 or missile 1 pixel, plot that colour - if(has_player1 || has_missile1) - { + if(has_player1 || has_missile1) { colour_mask_by_mode_collision_flags_[(int)ColourMode::Standard][c] = colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] = colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] = @@ -102,14 +96,12 @@ TIA::TIA(bool create_crt) : } // in the right-hand side of score mode, the playfield has the same priority as player 1 - if(has_playfield) - { + if(has_playfield) { colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] = (uint8_t)ColourIndex::PlayerMissile1; } // next test for everybody: if there is a player 0 or missile 0 pixel, plot that colour instead - if(has_player0 || has_missile0) - { + if(has_player0 || has_missile0) { colour_mask_by_mode_collision_flags_[(int)ColourMode::Standard][c] = colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] = colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] = @@ -117,14 +109,12 @@ TIA::TIA(bool create_crt) : } // if this is the left-hand side of score mode, the playfield has the same priority as player 0 - if(has_playfield) - { + if(has_playfield) { colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] = (uint8_t)ColourIndex::PlayerMissile0; } // a final test for 'on top' priority mode: if the playfield or ball are visible, prefer that colour to all others - if(has_playfield || has_ball) - { + if(has_playfield || has_ball) { colour_mask_by_mode_collision_flags_[(int)ColourMode::OnTop][c] = (uint8_t)ColourIndex::PlayfieldBall; } } @@ -132,17 +122,14 @@ TIA::TIA(bool create_crt) : TIA::TIA() : TIA(true) {} -TIA::TIA(std::function line_end_function) : TIA(false) -{ +TIA::TIA(std::function line_end_function) : TIA(false) { line_end_function_ = line_end_function; } -void TIA::set_output_mode(Atari2600::TIA::OutputMode output_mode) -{ +void TIA::set_output_mode(Atari2600::TIA::OutputMode output_mode) { Outputs::CRT::DisplayType display_type; - if(output_mode == OutputMode::NTSC) - { + if(output_mode == OutputMode::NTSC) { crt_->set_composite_sampling_function( "float composite_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)" "{" @@ -154,9 +141,7 @@ void TIA::set_output_mode(Atari2600::TIA::OutputMode output_mode) "return mix(float(y) / 14.0, step(1, iPhase) * cos(phase + phaseOffset), amplitude);" "}"); display_type = Outputs::CRT::DisplayType::NTSC60; - } - else - { + } else { crt_->set_composite_sampling_function( "float composite_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)" "{" @@ -183,56 +168,46 @@ void TIA::set_output_mode(Atari2600::TIA::OutputMode output_mode) void TIA::run_for_cycles(int number_of_cycles) { // if part way through a line, definitely perform a partial, at most up to the end of the line - if(horizontal_counter_) - { + if(horizontal_counter_) { int cycles = std::min(number_of_cycles, cycles_per_line - horizontal_counter_); output_for_cycles(cycles); number_of_cycles -= cycles; } // output full lines for as long as possible - while(number_of_cycles >= cycles_per_line) - { + while(number_of_cycles >= cycles_per_line) { output_line(); number_of_cycles -= cycles_per_line; } // partly start a new line if necessary - if(number_of_cycles) - { + if(number_of_cycles) { output_for_cycles(number_of_cycles); } } -void TIA::set_sync(bool sync) -{ +void TIA::set_sync(bool sync) { output_mode_ = (output_mode_ & ~sync_flag) | (sync ? sync_flag : 0); } -void TIA::set_blank(bool blank) -{ +void TIA::set_blank(bool blank) { output_mode_ = (output_mode_ & ~blank_flag) | (blank ? blank_flag : 0); } -void TIA::reset_horizontal_counter() -{ +void TIA::reset_horizontal_counter() { } -int TIA::get_cycles_until_horizontal_blank(unsigned int from_offset) -{ +int TIA::get_cycles_until_horizontal_blank(unsigned int from_offset) { return (cycles_per_line - (horizontal_counter_ + (int)from_offset) % cycles_per_line) % cycles_per_line; } -void TIA::set_background_colour(uint8_t colour) -{ +void TIA::set_background_colour(uint8_t colour) { colour_palette_[(int)ColourIndex::Background] = colour; } -void TIA::set_playfield(uint16_t offset, uint8_t value) -{ +void TIA::set_playfield(uint16_t offset, uint8_t value) { assert(offset >= 0 && offset < 3); - switch(offset) - { + switch(offset) { case 0: background_[1] = (background_[1] & 0x0ffff) | ((uint32_t)reverse_table[value & 0xf0] << 16); background_[0] = (background_[0] & 0xffff0) | (uint32_t)(value >> 4); @@ -248,11 +223,9 @@ void TIA::set_playfield(uint16_t offset, uint8_t value) } } -void TIA::set_playfield_control_and_ball_size(uint8_t value) -{ +void TIA::set_playfield_control_and_ball_size(uint8_t value) { background_half_mask_ = value & 1; - switch(value & 6) - { + switch(value & 6) { case 0: playfield_priority_ = PlayfieldPriority::Standard; break; @@ -268,17 +241,14 @@ void TIA::set_playfield_control_and_ball_size(uint8_t value) ball_.size = 1 << ((value >> 4)&3); } -void TIA::set_playfield_ball_colour(uint8_t colour) -{ +void TIA::set_playfield_ball_colour(uint8_t colour) { colour_palette_[(int)ColourIndex::PlayfieldBall] = colour; } -void TIA::set_player_number_and_size(int player, uint8_t value) -{ +void TIA::set_player_number_and_size(int player, uint8_t value) { assert(player >= 0 && player < 2); int size = 0; - switch(value & 7) - { + switch(value & 7) { case 0: case 1: case 2: case 3: case 4: player_[player].copy_flags = value & 7; break; @@ -300,28 +270,24 @@ void TIA::set_player_number_and_size(int player, uint8_t value) player_[player].adder = 4 >> size; } -void TIA::set_player_graphic(int player, uint8_t value) -{ +void TIA::set_player_graphic(int player, uint8_t value) { assert(player >= 0 && player < 2); player_[player].graphic[1] = value; player_[player^1].graphic[0] = player_[player^1].graphic[1]; if(player) ball_.enabled[0] = ball_.enabled[1]; } -void TIA::set_player_reflected(int player, bool reflected) -{ +void TIA::set_player_reflected(int player, bool reflected) { assert(player >= 0 && player < 2); player_[player].reverse_mask = reflected ? 7 : 0; } -void TIA::set_player_delay(int player, bool delay) -{ +void TIA::set_player_delay(int player, bool delay) { assert(player >= 0 && player < 2); player_[player].graphic_index = delay ? 0 : 1; } -void TIA::set_player_position(int player) -{ +void TIA::set_player_position(int player) { assert(player >= 0 && player < 2); // players have an extra clock of delay before output and don't display upon reset; // both aims are achieved by setting to -1 because: (i) it causes the clock to be @@ -331,91 +297,76 @@ void TIA::set_player_position(int player) player_[player].position = -1; } -void TIA::set_player_motion(int player, uint8_t motion) -{ +void TIA::set_player_motion(int player, uint8_t motion) { assert(player >= 0 && player < 2); player_[player].motion = (motion >> 4)&0xf; } -void TIA::set_player_missile_colour(int player, uint8_t colour) -{ +void TIA::set_player_missile_colour(int player, uint8_t colour) { assert(player >= 0 && player < 2); colour_palette_[(int)ColourIndex::PlayerMissile0 + player] = colour; } -void TIA::set_missile_enable(int missile, bool enabled) -{ +void TIA::set_missile_enable(int missile, bool enabled) { assert(missile >= 0 && missile < 2); missile_[missile].enabled = enabled; } -void TIA::set_missile_position(int missile) -{ +void TIA::set_missile_position(int missile) { assert(missile >= 0 && missile < 2); missile_[missile].position = 0; } -void TIA::set_missile_position_to_player(int missile, bool lock) -{ +void TIA::set_missile_position_to_player(int missile, bool lock) { assert(missile >= 0 && missile < 2); missile_[missile].locked_to_player = lock; player_[missile].latched_pixel4_time = -1; } -void TIA::set_missile_motion(int missile, uint8_t motion) -{ +void TIA::set_missile_motion(int missile, uint8_t motion) { assert(missile >= 0 && missile < 2); missile_[missile].motion = (motion >> 4)&0xf; } -void TIA::set_ball_enable(bool enabled) -{ +void TIA::set_ball_enable(bool enabled) { ball_.enabled[1] = enabled; } -void TIA::set_ball_delay(bool delay) -{ +void TIA::set_ball_delay(bool delay) { ball_.enabled_index = delay ? 0 : 1; } -void TIA::set_ball_position() -{ +void TIA::set_ball_position() { ball_.position = 0; // setting the ball position also triggers a draw ball_.reset_pixels(0); } -void TIA::set_ball_motion(uint8_t motion) -{ +void TIA::set_ball_motion(uint8_t motion) { ball_.motion = (motion >> 4) & 0xf; } -void TIA::move() -{ +void TIA::move() { horizontal_blank_extend_ = true; player_[0].is_moving = player_[1].is_moving = missile_[0].is_moving = missile_[1].is_moving = ball_.is_moving = true; player_[0].motion_step = player_[1].motion_step = missile_[0].motion_step = missile_[1].motion_step = ball_.motion_step = 15; player_[0].motion_time = player_[1].motion_time = missile_[0].motion_time = missile_[1].motion_time = ball_.motion_time = (horizontal_counter_ + 3) & ~3; } -void TIA::clear_motion() -{ +void TIA::clear_motion() { player_[0].motion = player_[1].motion = missile_[0].motion = missile_[1].motion = ball_.motion = 0; } -uint8_t TIA::get_collision_flags(int offset) -{ +uint8_t TIA::get_collision_flags(int offset) { return (uint8_t)((collision_flags_ >> (offset << 1)) << 6) & 0xc0; } -void TIA::clear_collision_flags() -{ +void TIA::clear_collision_flags() { collision_flags_ = 0; } -void TIA::output_for_cycles(int number_of_cycles) -{ +void TIA::output_for_cycles(int number_of_cycles) { /* Line timing is oriented around 0 being the start of the right-hand side vertical blank; a wsync synchronises the CPU to horizontal_counter_ = 0. All timing below is in terms of the @@ -434,8 +385,7 @@ void TIA::output_for_cycles(int number_of_cycles) horizontal_counter_ += number_of_cycles; bool is_reset = output_cursor < 224 && horizontal_counter_ >= 224; - if(!output_cursor) - { + if(!output_cursor) { if(line_end_function_) line_end_function_(collision_buffer_); memset(collision_buffer_, 0, sizeof(collision_buffer_)); @@ -459,23 +409,18 @@ void TIA::output_for_cycles(int number_of_cycles) // convert to television signals #define Period(function, target) \ - if(output_cursor < target) \ - { \ - if(horizontal_counter_ <= target) \ - { \ + if(output_cursor < target) { \ + if(horizontal_counter_ <= target) { \ if(crt_) crt_->function((unsigned int)((horizontal_counter_ - output_cursor) * 2)); \ horizontal_counter_ %= cycles_per_line; \ return; \ - } \ - else \ - { \ + } else { \ if(crt_) crt_->function((unsigned int)((target - output_cursor) * 2)); \ output_cursor = target; \ } \ } - switch(output_mode_) - { + switch(output_mode_) { default: Period(output_blank, 16) Period(output_sync, 32) @@ -493,10 +438,8 @@ void TIA::output_for_cycles(int number_of_cycles) #undef Period - if(output_mode_ & blank_flag) - { - if(pixel_target_) - { + if(output_mode_ & blank_flag) { + if(pixel_target_) { output_pixels(pixels_start_location_, output_cursor); if(crt_) crt_->output_data((unsigned int)(output_cursor - pixels_start_location_) * 2, 2); pixel_target_ = nullptr; @@ -504,11 +447,8 @@ void TIA::output_for_cycles(int number_of_cycles) } int duration = std::min(228, horizontal_counter_) - output_cursor; if(crt_) crt_->output_blank((unsigned int)(duration * 2)); - } - else - { - if(!pixels_start_location_ && crt_) - { + } else { + if(!pixels_start_location_ && crt_) { pixels_start_location_ = output_cursor; pixel_target_ = crt_->allocate_write_area(160); } @@ -517,14 +457,12 @@ void TIA::output_for_cycles(int number_of_cycles) if(pixel_target_) output_pixels(output_cursor, horizontal_counter_); // accumulate collision flags - while(output_cursor < horizontal_counter_) - { + while(output_cursor < horizontal_counter_) { collision_flags_ |= collision_flags_by_buffer_vaules_[collision_buffer_[output_cursor - first_pixel_cycle]]; output_cursor++; } - if(horizontal_counter_ == cycles_per_line && crt_) - { + if(horizontal_counter_ == cycles_per_line && crt_) { crt_->output_data((unsigned int)(output_cursor - pixels_start_location_) * 2, 2); pixel_target_ = nullptr; pixels_start_location_ = 0; @@ -536,43 +474,34 @@ void TIA::output_for_cycles(int number_of_cycles) horizontal_counter_ %= cycles_per_line; } -void TIA::output_pixels(int start, int end) -{ +void TIA::output_pixels(int start, int end) { start = std::max(start, pixels_start_location_); int target_position = start - pixels_start_location_; - if(start < first_pixel_cycle+8 && horizontal_blank_extend_) - { - while(start < end && start < first_pixel_cycle+8) - { + if(start < first_pixel_cycle+8 && horizontal_blank_extend_) { + while(start < end && start < first_pixel_cycle+8) { pixel_target_[target_position] = 0; start++; target_position++; } } - if(playfield_priority_ == PlayfieldPriority::Score) - { - while(start < end && start < first_pixel_cycle + 80) - { + if(playfield_priority_ == PlayfieldPriority::Score) { + while(start < end && start < first_pixel_cycle + 80) { uint8_t buffer_value = collision_buffer_[start - first_pixel_cycle]; pixel_target_[target_position] = colour_palette_[colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][buffer_value]]; start++; target_position++; } - while(start < end) - { + while(start < end) { uint8_t buffer_value = collision_buffer_[start - first_pixel_cycle]; pixel_target_[target_position] = colour_palette_[colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][buffer_value]]; start++; target_position++; } - } - else - { + } else { int table_index = (int)((playfield_priority_ == PlayfieldPriority::Standard) ? ColourMode::Standard : ColourMode::OnTop); - while(start < end) - { + while(start < end) { uint8_t buffer_value = collision_buffer_[start - first_pixel_cycle]; pixel_target_[target_position] = colour_palette_[colour_mask_by_mode_collision_flags_[table_index][buffer_value]]; start++; @@ -581,18 +510,15 @@ void TIA::output_pixels(int start, int end) } } -void TIA::output_line() -{ - switch(output_mode_) - { +void TIA::output_line() { + switch(output_mode_) { default: // TODO: optimise special case output_for_cycles(cycles_per_line); break; case sync_flag: case sync_flag | blank_flag: - if(crt_) - { + if(crt_) { crt_->output_sync(32); crt_->output_blank(32); crt_->output_sync(392); @@ -600,8 +526,7 @@ void TIA::output_line() horizontal_blank_extend_ = false; break; case blank_flag: - if(crt_) - { + if(crt_) { crt_->output_blank(32); crt_->output_sync(32); crt_->output_default_colour_burst(32); @@ -614,8 +539,7 @@ void TIA::output_line() #pragma mark - Playfield output -void TIA::draw_playfield(int start, int end) -{ +void TIA::draw_playfield(int start, int end) { // don't do anything if this window ends too early if(end < first_pixel_cycle) return; @@ -625,8 +549,7 @@ void TIA::draw_playfield(int start, int end) // proceed along four-pixel boundaries, plotting four pixels at a time int aligned_position = (start + 3)&~3; - while(aligned_position < end) - { + while(aligned_position < end) { int offset = (aligned_position - first_pixel_cycle) >> 2; uint32_t value = ((background_[(offset/20)&background_half_mask_] >> (offset%20))&1) * 0x01010101; *(uint32_t *)&collision_buffer_[aligned_position - first_pixel_cycle] |= value; @@ -636,12 +559,10 @@ void TIA::draw_playfield(int start, int end) #pragma mark - Motion -template void TIA::perform_motion_step(T &object) -{ - if((object.motion_step ^ (object.motion ^ 8)) == 0xf) +template void TIA::perform_motion_step(T &object) { + if((object.motion_step ^ (object.motion ^ 8)) == 0xf) { object.is_moving = false; - else - { + } else { if(object.position == 159) object.reset_pixels(0); else if(object.position == 15 && object.copy_flags&1) object.reset_pixels(1); else if(object.position == 31 && object.copy_flags&2) object.reset_pixels(2); @@ -653,21 +574,18 @@ template void TIA::perform_motion_step(T &object) } } -template void TIA::perform_border_motion(T &object, int start, int end) -{ +template void TIA::perform_border_motion(T &object, int start, int end) { while(object.is_moving && object.motion_time < end) perform_motion_step(object); } -template void TIA::draw_object(T &object, const uint8_t collision_identity, int start, int end) -{ +template void TIA::draw_object(T &object, const uint8_t collision_identity, int start, int end) { int first_pixel = first_pixel_cycle - 4 + (horizontal_blank_extend_ ? 8 : 0); object.dequeue_pixels(collision_buffer_, collision_identity, end - first_pixel_cycle); // movement works across the entire screen, so do work that falls outside of the pixel area - if(start < first_pixel) - { + if(start < first_pixel) { perform_border_motion(object, start, std::max(end, first_pixel)); } @@ -677,47 +595,38 @@ template void TIA::draw_object(T &object, const uint8_t collision_ident if(start >= end) return; // perform the visible part of the line, if any - if(start < 224) - { + if(start < 224) { draw_object_visible(object, collision_identity, start - first_pixel_cycle + 4, std::min(end - first_pixel_cycle + 4, 160), end - first_pixel_cycle); } // move further if required - if(object.is_moving && end >= 224 && object.motion_time < end) - { + if(object.is_moving && end >= 224 && object.motion_time < end) { perform_motion_step(object); } } -template void TIA::draw_object_visible(T &object, const uint8_t collision_identity, int start, int end, int time_now) -{ +template void TIA::draw_object_visible(T &object, const uint8_t collision_identity, int start, int end, int time_now) { // perform a miniature event loop on (i) triggering draws; (ii) drawing; and (iii) motion int next_motion_time = object.motion_time - first_pixel_cycle + 4; - while(start < end) - { + while(start < end) { int next_event_time = end; // is the next event a movement tick? - if(object.is_moving && next_motion_time < next_event_time) - { + if(object.is_moving && next_motion_time < next_event_time) { next_event_time = next_motion_time; } // is the next event a graphics trigger? int next_copy = 160; int next_copy_id = 0; - if(object.copy_flags) - { - if(object.position < 16 && object.copy_flags&1) - { + if(object.copy_flags) { + if(object.position < 16 && object.copy_flags&1) { next_copy = 16; next_copy_id = 1; - } else if(object.position < 32 && object.copy_flags&2) - { + } else if(object.position < 32 && object.copy_flags&2) { next_copy = 32; next_copy_id = 2; - } else if(object.position < 64 && object.copy_flags&4) - { + } else if(object.position < 64 && object.copy_flags&4) { next_copy = 64; next_copy_id = 3; } @@ -731,20 +640,14 @@ template void TIA::draw_object_visible(T &object, const uint8_t collisi // enqueue a future intention to draw pixels if spitting them out now would violate accuracy; // otherwise draw them now - if(object.enqueues && next_event_time > time_now) - { - if(start < time_now) - { + if(object.enqueues && next_event_time > time_now) { + if(start < time_now) { object.output_pixels(&collision_buffer_[start], time_now - start, collision_identity, start + first_pixel_cycle - 4); object.enqueue_pixels(time_now, next_event_time, time_now + first_pixel_cycle - 4); - } - else - { + } else { object.enqueue_pixels(start, next_event_time, start + first_pixel_cycle - 4); } - } - else - { + } else { object.output_pixels(&collision_buffer_[start], length, collision_identity, start + first_pixel_cycle - 4); } @@ -752,15 +655,11 @@ template void TIA::draw_object_visible(T &object, const uint8_t collisi object.position = (object.position + length) % 160; start = next_event_time; - // if the event is a motion tick, apply - if(object.is_moving && start == next_motion_time) - { + // if the event is a motion tick, apply; if it's a draw trigger, trigger a draw + if(object.is_moving && start == next_motion_time) { perform_motion_step(object); next_motion_time += 4; - } - // if it's a draw trigger, trigger a draw - else if(start == next_copy_time) - { + } else if(start == next_copy_time) { object.reset_pixels(next_copy_id); } } @@ -768,14 +667,10 @@ template void TIA::draw_object_visible(T &object, const uint8_t collisi #pragma mark - Missile drawing -void TIA::draw_missile(Missile &missile, Player &player, const uint8_t collision_identity, int start, int end) -{ - if(!missile.locked_to_player || player.latched_pixel4_time < 0) - { +void TIA::draw_missile(Missile &missile, Player &player, const uint8_t collision_identity, int start, int end) { + if(!missile.locked_to_player || player.latched_pixel4_time < 0) { draw_object(missile, collision_identity, start, end); - } - else - { + } else { draw_object(missile, collision_identity, start, player.latched_pixel4_time); missile.position = 0; draw_object(missile, collision_identity, player.latched_pixel4_time, end); diff --git a/Machines/Atari2600/TIA.hpp b/Machines/Atari2600/TIA.hpp index 0da88e74b..eca7a29b9 100644 --- a/Machines/Atari2600/TIA.hpp +++ b/Machines/Atari2600/TIA.hpp @@ -162,52 +162,42 @@ class TIA { int latched_pixel4_time; const bool enqueues = true; - inline void skip_pixels(const int count, int from_horizontal_counter) - { + inline void skip_pixels(const int count, int from_horizontal_counter) { int old_pixel_counter = pixel_counter; pixel_position = std::min(32, pixel_position + count * adder); pixel_counter += count; - if(!copy_index_ && old_pixel_counter < 4 && pixel_counter >= 4) - { + if(!copy_index_ && old_pixel_counter < 4 && pixel_counter >= 4) { latched_pixel4_time = from_horizontal_counter + 4 - old_pixel_counter; } } - inline void reset_pixels(int copy) - { + inline void reset_pixels(int copy) { pixel_position = pixel_counter = 0; copy_index_ = copy; } - inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) - { + inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) { output_pixels(target, count, collision_identity, pixel_position, adder, reverse_mask); skip_pixels(count, from_horizontal_counter); } - void dequeue_pixels(uint8_t *const target, const uint8_t collision_identity, const int time_now) - { - while(queue_read_pointer_ != queue_write_pointer_) - { + void dequeue_pixels(uint8_t *const target, const uint8_t collision_identity, const int time_now) { + while(queue_read_pointer_ != queue_write_pointer_) { uint8_t *const start_ptr = &target[queue_[queue_read_pointer_].start]; - if(queue_[queue_read_pointer_].end > time_now) - { + if(queue_[queue_read_pointer_].end > time_now) { const int length = time_now - queue_[queue_read_pointer_].start; output_pixels(start_ptr, length, collision_identity, queue_[queue_read_pointer_].pixel_position, queue_[queue_read_pointer_].adder, queue_[queue_read_pointer_].reverse_mask); queue_[queue_read_pointer_].pixel_position += length * queue_[queue_read_pointer_].adder; queue_[queue_read_pointer_].start = time_now; return; - } - else - { + } else { output_pixels(start_ptr, queue_[queue_read_pointer_].end - queue_[queue_read_pointer_].start, collision_identity, queue_[queue_read_pointer_].pixel_position, queue_[queue_read_pointer_].adder, queue_[queue_read_pointer_].reverse_mask); } queue_read_pointer_ = (queue_read_pointer_ + 1)&3; } } - void enqueue_pixels(const int start, const int end, int from_horizontal_counter) - { + void enqueue_pixels(const int start, const int end, int from_horizontal_counter) { queue_[queue_write_pointer_].start = start; queue_[queue_write_pointer_].end = end; queue_[queue_write_pointer_].pixel_position = pixel_position; @@ -219,8 +209,7 @@ class TIA { private: int copy_index_; - struct QueuedPixels - { + struct QueuedPixels { int start, end; int pixel_position; int adder; @@ -228,12 +217,10 @@ class TIA { } queue_[4]; int queue_read_pointer_, queue_write_pointer_; - inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int pixel_position, int adder, int reverse_mask) - { + inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int pixel_position, int adder, int reverse_mask) { if(pixel_position == 32 || !graphic[graphic_index]) return; int output_cursor = 0; - while(pixel_position < 32 && output_cursor < count) - { + while(pixel_position < 32 && output_cursor < count) { int shift = (pixel_position >> 2) ^ reverse_mask; target[output_cursor] |= ((graphic[graphic_index] >> shift)&1) * collision_identity; output_cursor++; @@ -249,18 +236,15 @@ class TIA { int size; const bool enqueues = false; - inline void skip_pixels(const int count, int from_horizontal_counter) - { + inline void skip_pixels(const int count, int from_horizontal_counter) { pixel_position = std::max(0, pixel_position - count); } - inline void reset_pixels(int copy) - { + inline void reset_pixels(int copy) { pixel_position = size; } - inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) - { + inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) { int output_cursor = 0; while(pixel_position && output_cursor < count) { @@ -283,15 +267,11 @@ class TIA { bool locked_to_player; int copy_flags; - inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) - { + inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) { if(!pixel_position) return; - if(enabled && !locked_to_player) - { + if(enabled && !locked_to_player) { HorizontalRun::output_pixels(target, count, collision_identity, from_horizontal_counter); - } - else - { + } else { skip_pixels(count, from_horizontal_counter); } } @@ -305,15 +285,11 @@ class TIA { int enabled_index; const int copy_flags = 0; - inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) - { + inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) { if(!pixel_position) return; - if(enabled[enabled_index]) - { + if(enabled[enabled_index]) { HorizontalRun::output_pixels(target, count, collision_identity, from_horizontal_counter); - } - else - { + } else { skip_pixels(count, from_horizontal_counter); } }