6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2025-02-23 03:29:04 +00:00
Code Issues Projects Releases Wiki Activity

Pull out and partially generalise sprite output.

Browse Source 
This also provides the intended route to supporting Mode 2.
This commit is contained in:
Thomas Harte 2023-02-21 22:00:00 -05:00
parent 62d381065e
commit 6a2cda7074
4 changed files with 208 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Components/9918/Implementation/9918Base.hpp
View File

@ -540,12 +540,14 @@ template <Personality personality> struct Base: public Storage<personality> {
bool asked_for_write_area_ = false; bool asked_for_write_area_ = false;
// Output serialisers. // Output serialisers.
void draw_tms_character(int start, int end); template <SpriteMode mode = SpriteMode::Mode1> void draw_tms_character(int start, int end);
template <bool apply_blink> void draw_tms_text(int start, int end); template <bool apply_blink> void draw_tms_text(int start, int end);
void draw_sms(int start, int end, uint32_t cram_dot); void draw_sms(int start, int end, uint32_t cram_dot);
template<ScreenMode mode> void draw_yamaha(LineBuffer &, int start, int end); template<ScreenMode mode> void draw_yamaha(LineBuffer &, int start, int end);
void draw_yamaha(int start, int end); void draw_yamaha(int start, int end);
template <SpriteMode mode, bool double_width> void draw_sprites(LineBuffer &, int start, int end, int *colour_buffer = nullptr);
}; };
#include "Fetch.hpp" #include "Fetch.hpp"

6
Components/9918/Implementation/AccessEnums.hpp
View File

@ -79,6 +79,12 @@ enum class VerticalState {
Pixels, Pixels,
}; };
enum class SpriteMode {
Mode1,
Mode2,
MasterSystem,
};
} }
} }

386
Components/9918/Implementation/Draw.hpp
View File

@ -9,9 +9,110 @@
#ifndef Draw_hpp #ifndef Draw_hpp
#define Draw_hpp #define Draw_hpp
// MARK: - Sprites, as generalised.
template <Personality personality>
template <SpriteMode mode, bool double_width>
void Base<personality>::draw_sprites(LineBuffer &buffer, int start, int end, int *colour_buffer) {
if(!buffer.active_sprite_slot) {
return;
}
const int shift_advance = sprites_magnified_ ? 1 : 2;
// If this is the start of the line clip any part of any sprites that is off to the left.
if(!start) {
for(int index = 0; index < buffer.active_sprite_slot; ++index) {
LineBuffer::ActiveSprite &sprite = buffer.active_sprites[index];
if(sprite.x < 0) sprite.shift_position -= shift_advance * sprite.x;
}
}
int sprite_buffer[256];
int sprite_collision = 0;
memset(&sprite_buffer[start], 0, size_t(end - start)*sizeof(sprite_buffer[0]));
if constexpr (mode == SpriteMode::MasterSystem) {
// Draw all sprites into the sprite buffer.
for(int index = buffer.active_sprite_slot - 1; index >= 0; --index) {
LineBuffer::ActiveSprite &sprite = buffer.active_sprites[index];
if(sprite.shift_position < 16) {
const int pixel_start = std::max(start, sprite.x);
// TODO: it feels like the work below should be simplifiable;
// the double shift in particular, and hopefully the variable shift.
for(int c = pixel_start; c < end && sprite.shift_position < 16; ++c) {
const int shift = (sprite.shift_position >> 1);
const int sprite_colour =
(((sprite.image[3] << shift) & 0x80) >> 4) |
(((sprite.image[2] << shift) & 0x80) >> 5) |
(((sprite.image[1] << shift) & 0x80) >> 6) |
(((sprite.image[0] << shift) & 0x80) >> 7);
if(sprite_colour) {
sprite_collision |= sprite_buffer[c];
sprite_buffer[c] = sprite_colour | 0x10;
}
sprite.shift_position += shift_advance;
}
}
}
// Draw the sprite buffer onto the colour buffer, wherever the tile map doesn't have
// priority (or is transparent).
for(int c = start; c < end; ++c) {
if(
sprite_buffer[c] &&
(!(colour_buffer[c]&0x20) || !(colour_buffer[c]&0xf))
) colour_buffer[c] = sprite_buffer[c];
}
if(sprite_collision)
status_ |= StatusSpriteCollision;
return;
}
constexpr uint32_t sprite_colour_selection_masks[2] = {0x00000000, 0xffffffff};
constexpr int colour_masks[16] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
// TODO: real Mode 2 logic.
if constexpr (mode == SpriteMode::Mode1 || mode == SpriteMode::Mode2) {
// Draw all sprites into the sprite buffer.
const int shifter_target = sprites_16x16_ ? 32 : 16;
for(int index = buffer.active_sprite_slot - 1; index >= 0; --index) {
LineBuffer::ActiveSprite &sprite = buffer.active_sprites[index];
if(sprite.shift_position < shifter_target) {
const int pixel_start = std::max(start, sprite.x);
for(int c = pixel_start; c < end && sprite.shift_position < shifter_target; ++c) {
const int shift = (sprite.shift_position >> 1) ^ 7;
int sprite_colour = (sprite.image[shift >> 3] >> (shift & 7)) & 1;
// A colision is detected regardless of sprite colour ...
sprite_collision |= sprite_buffer[c] & sprite_colour;
sprite_buffer[c] |= sprite_colour;
// ... but a sprite with the transparent colour won't actually be visible.
sprite_colour &= colour_masks[sprite.image[2]&15];
pixel_origin_[c] =
(pixel_origin_[c] & sprite_colour_selection_masks[sprite_colour^1]) |
(palette()[sprite.image[2]&15] & sprite_colour_selection_masks[sprite_colour]);
sprite.shift_position += shift_advance;
}
}
}
status_ |= sprite_collision << StatusSpriteCollisionShift;
return;
}
}
// MARK: - TMS9918 // MARK: - TMS9918
template <Personality personality> template <Personality personality>
template <SpriteMode sprite_mode>
void Base<personality>::draw_tms_character(int start, int end) { void Base<personality>::draw_tms_character(int start, int end) {
LineBuffer &line_buffer = line_buffers_[output_pointer_.row]; LineBuffer &line_buffer = line_buffers_[output_pointer_.row];
@ -56,52 +157,7 @@ void Base<personality>::draw_tms_character(int start, int end) {
} }
} }
// Paint sprites and check for collisions, but only if at least one sprite is active draw_sprites<sprite_mode, false>(line_buffer, start, end);
// on this line.
if(line_buffer.active_sprite_slot) {
const int shift_advance = sprites_magnified_ ? 1 : 2;
// If this is the start of the line clip any part of any sprites that is off to the left.
if(!start) {
for(int index = 0; index < line_buffer.active_sprite_slot; ++index) {
LineBuffer::ActiveSprite &sprite = line_buffer.active_sprites[index];
if(sprite.x < 0) sprite.shift_position -= shift_advance * sprite.x;
}
}
int sprite_buffer[256];
int sprite_collision = 0;
memset(&sprite_buffer[start], 0, size_t(end - start)*sizeof(sprite_buffer[0]));
constexpr uint32_t sprite_colour_selection_masks[2] = {0x00000000, 0xffffffff};
constexpr int colour_masks[16] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
// Draw all sprites into the sprite buffer.
const int shifter_target = sprites_16x16_ ? 32 : 16;
for(int index = line_buffer.active_sprite_slot - 1; index >= 0; --index) {
LineBuffer::ActiveSprite &sprite = line_buffer.active_sprites[index];
if(sprite.shift_position < shifter_target) {
const int pixel_start = std::max(start, sprite.x);
for(int c = pixel_start; c < end && sprite.shift_position < shifter_target; ++c) {
const int shift = (sprite.shift_position >> 1) ^ 7;
int sprite_colour = (sprite.image[shift >> 3] >> (shift & 7)) & 1;
// A colision is detected regardless of sprite colour ...
sprite_collision |= sprite_buffer[c] & sprite_colour;
sprite_buffer[c] |= sprite_colour;
// ... but a sprite with the transparent colour won't actually be visible.
sprite_colour &= colour_masks[sprite.image[2]&15];
pixel_origin_[c] =
(pixel_origin_[c] & sprite_colour_selection_masks[sprite_colour^1]) |
(palette()[sprite.image[2]&15] & sprite_colour_selection_masks[sprite_colour]);
sprite.shift_position += shift_advance;
}
}
}
status_ |= sprite_collision << StatusSpriteCollisionShift;
}
} }
template <Personality personality> template <Personality personality>
@ -150,156 +206,102 @@ void Base<personality>::draw_tms_text(int start, int end) {
template <Personality personality> template <Personality personality>
void Base<personality>::draw_sms(int start, int end, uint32_t cram_dot) { void Base<personality>::draw_sms(int start, int end, uint32_t cram_dot) {
if constexpr (is_sega_vdp(personality)) { if constexpr (is_sega_vdp(personality)) {
LineBuffer &line_buffer = line_buffers_[output_pointer_.row];
int colour_buffer[256];
LineBuffer &line_buffer = line_buffers_[output_pointer_.row]; /*
int colour_buffer[256]; Add extra border for any pixels that fall before the fine scroll.
*/
/* int tile_start = start, tile_end = end;
Add extra border for any pixels that fall before the fine scroll. int tile_offset = start;
*/ if(output_pointer_.row >= 16 || !Storage<personality>::horizontal_scroll_lock_) {
int tile_start = start, tile_end = end; for(int c = start; c < (line_buffer.latched_horizontal_scroll & 7); ++c) {
int tile_offset = start; colour_buffer[c] = 16 + background_colour_;
if(output_pointer_.row >= 16 || !Storage<personality>::horizontal_scroll_lock_) { ++tile_offset;
for(int c = start; c < (line_buffer.latched_horizontal_scroll & 7); ++c) {
colour_buffer[c] = 16 + background_colour_;
++tile_offset;
}
// Remove the border area from that to which tiles will be drawn.
tile_start = std::max(start - (line_buffer.latched_horizontal_scroll & 7), 0);
tile_end = std::max(end - (line_buffer.latched_horizontal_scroll & 7), 0);
}
uint32_t pattern;
uint8_t *const pattern_index = reinterpret_cast<uint8_t *>(&pattern);
/*
Add background tiles; these will fill the colour_buffer with values in which
the low five bits are a palette index, and bit six is set if this tile has
priority over sprites.
*/
if(tile_start < end) {
const int shift = tile_start & 7;
int byte_column = tile_start >> 3;
int pixels_left = tile_end - tile_start;
int length = std::min(pixels_left, 8 - shift);
pattern = *reinterpret_cast<const uint32_t *>(line_buffer.tiles.patterns[byte_column]);
if(line_buffer.tiles.flags[byte_column]&2)
pattern >>= shift;
else
pattern <<= shift;
while(true) {
const int palette_offset = (line_buffer.tiles.flags[byte_column]&0x18) << 1;
if(line_buffer.tiles.flags[byte_column]&2) {
for(int c = 0; c < length; ++c) {
colour_buffer[tile_offset] =
((pattern_index[3] & 0x01) << 3) |
((pattern_index[2] & 0x01) << 2) |
((pattern_index[1] & 0x01) << 1) |
((pattern_index[0] & 0x01) << 0) |
palette_offset;
++tile_offset;
pattern >>= 1;
}
} else {
for(int c = 0; c < length; ++c) {
colour_buffer[tile_offset] =
((pattern_index[3] & 0x80) >> 4) |
((pattern_index[2] & 0x80) >> 5) |
((pattern_index[1] & 0x80) >> 6) |
((pattern_index[0] & 0x80) >> 7) |
palette_offset;
++tile_offset;
pattern <<= 1;
}
} }
pixels_left -= length; // Remove the border area from that to which tiles will be drawn.
if(!pixels_left) break; tile_start = std::max(start - (line_buffer.latched_horizontal_scroll & 7), 0);
tile_end = std::max(end - (line_buffer.latched_horizontal_scroll & 7), 0);
}
uint32_t pattern;
uint8_t *const pattern_index = reinterpret_cast<uint8_t *>(&pattern);
/*
Add background tiles; these will fill the colour_buffer with values in which
the low five bits are a palette index, and bit six is set if this tile has
priority over sprites.
*/
if(tile_start < end) {
const int shift = tile_start & 7;
int byte_column = tile_start >> 3;
int pixels_left = tile_end - tile_start;
int length = std::min(pixels_left, 8 - shift);
length = std::min(8, pixels_left);
byte_column++;
pattern = *reinterpret_cast<const uint32_t *>(line_buffer.tiles.patterns[byte_column]); pattern = *reinterpret_cast<const uint32_t *>(line_buffer.tiles.patterns[byte_column]);
} if(line_buffer.tiles.flags[byte_column]&2)
} pattern >>= shift;
else
pattern <<= shift;
/* while(true) {
Apply sprites (if any). const int palette_offset = (line_buffer.tiles.flags[byte_column]&0x18) << 1;
*/ if(line_buffer.tiles.flags[byte_column]&2) {
if(line_buffer.active_sprite_slot) { for(int c = 0; c < length; ++c) {
const int shift_advance = sprites_magnified_ ? 1 : 2; colour_buffer[tile_offset] =
((pattern_index[3] & 0x01) << 3) |
// If this is the start of the line clip any part of any sprites that is off to the left. ((pattern_index[2] & 0x01) << 2) |
if(!start) { ((pattern_index[1] & 0x01) << 1) |
for(int index = 0; index < line_buffer.active_sprite_slot; ++index) { ((pattern_index[0] & 0x01) << 0) |
LineBuffer::ActiveSprite &sprite = line_buffer.active_sprites[index]; palette_offset;
if(sprite.x < 0) sprite.shift_position -= shift_advance * sprite.x; ++tile_offset;
} pattern >>= 1;
} }
} else {
int sprite_buffer[256]; for(int c = 0; c < length; ++c) {
int sprite_collision = 0; colour_buffer[tile_offset] =
memset(&sprite_buffer[start], 0, size_t(end - start)*sizeof(sprite_buffer[0])); ((pattern_index[3] & 0x80) >> 4) |
((pattern_index[2] & 0x80) >> 5) |
// Draw all sprites into the sprite buffer. ((pattern_index[1] & 0x80) >> 6) |
for(int index = line_buffer.active_sprite_slot - 1; index >= 0; --index) { ((pattern_index[0] & 0x80) >> 7) |
LineBuffer::ActiveSprite &sprite = line_buffer.active_sprites[index]; palette_offset;
if(sprite.shift_position < 16) { ++tile_offset;
const int pixel_start = std::max(start, sprite.x); pattern <<= 1;
// TODO: it feels like the work below should be simplifiable;
// the double shift in particular, and hopefully the variable shift.
for(int c = pixel_start; c < end && sprite.shift_position < 16; ++c) {
const int shift = (sprite.shift_position >> 1);
const int sprite_colour =
(((sprite.image[3] << shift) & 0x80) >> 4) |
(((sprite.image[2] << shift) & 0x80) >> 5) |
(((sprite.image[1] << shift) & 0x80) >> 6) |
(((sprite.image[0] << shift) & 0x80) >> 7);
if(sprite_colour) {
sprite_collision |= sprite_buffer[c];
sprite_buffer[c] = sprite_colour | 0x10;
} }
sprite.shift_position += shift_advance;
} }
pixels_left -= length;
if(!pixels_left) break;
length = std::min(8, pixels_left);
byte_column++;
pattern = *reinterpret_cast<const uint32_t *>(line_buffer.tiles.patterns[byte_column]);
} }
} }
// Draw the sprite buffer onto the colour buffer, wherever the tile map doesn't have /*
// priority (or is transparent). Apply sprites (if any).
for(int c = start; c < end; ++c) { */
if( draw_sprites<SpriteMode::MasterSystem, false>(line_buffer, start, end, colour_buffer);
sprite_buffer[c] &&
(!(colour_buffer[c]&0x20) || !(colour_buffer[c]&0xf)) // Map from the 32-colour buffer to real output pixels, applying the specific CRAM dot if any.
) colour_buffer[c] = sprite_buffer[c]; pixel_target_[start] = Storage<personality>::colour_ram_[colour_buffer[start] & 0x1f] | cram_dot;
for(int c = start+1; c < end; ++c) {
pixel_target_[c] = Storage<personality>::colour_ram_[colour_buffer[c] & 0x1f];
} }
if(sprite_collision) // If the VDP is set to hide the left column and this is the final call that'll come
status_ |= StatusSpriteCollision; // this line, hide it.
} if(end == 256) {
if(Storage<personality>::hide_left_column_) {
// Map from the 32-colour buffer to real output pixels, applying the specific CRAM dot if any. pixel_origin_[0] = pixel_origin_[1] = pixel_origin_[2] = pixel_origin_[3] =
pixel_target_[start] = Storage<personality>::colour_ram_[colour_buffer[start] & 0x1f] | cram_dot; pixel_origin_[4] = pixel_origin_[5] = pixel_origin_[6] = pixel_origin_[7] =
for(int c = start+1; c < end; ++c) { Storage<personality>::colour_ram_[16 + background_colour_];
pixel_target_[c] = Storage<personality>::colour_ram_[colour_buffer[c] & 0x1f]; }
}
// If the VDP is set to hide the left column and this is the final call that'll come
// this line, hide it.
if(end == 256) {
if(Storage<personality>::hide_left_column_) {
pixel_origin_[0] = pixel_origin_[1] = pixel_origin_[2] = pixel_origin_[3] =
pixel_origin_[4] = pixel_origin_[5] = pixel_origin_[6] = pixel_origin_[7] =
Storage<personality>::colour_ram_[16 + background_colour_];
} }
} }
}
} }
// MARK: - Yamaha // MARK: - Yamaha
@ -307,7 +309,7 @@ void Base<personality>::draw_sms(int start, int end, uint32_t cram_dot) {
template <Personality personality> template <Personality personality>
template <ScreenMode mode> template <ScreenMode mode>
void Base<personality>::draw_yamaha(LineBuffer &buffer, int start, int end) { void Base<personality>::draw_yamaha(LineBuffer &buffer, int start, int end) {
// TODO: sprites. And all other graphics modes. // TODO: Many other graphics modes.
// TODO: much smarter loops. Duff plus a tail? // TODO: much smarter loops. Duff plus a tail?
if constexpr (mode == ScreenMode::YamahaGraphics4) { if constexpr (mode == ScreenMode::YamahaGraphics4) {
@ -316,8 +318,6 @@ void Base<personality>::draw_yamaha(LineBuffer &buffer, int start, int end) {
buffer.bitmap[c >> 1] >> ((((c & 1) ^ 1) << 2)) & 0xf buffer.bitmap[c >> 1] >> ((((c & 1) ^ 1) << 2)) & 0xf
]; ];
} }
return;
} }
if constexpr (mode == ScreenMode::YamahaGraphics5) { if constexpr (mode == ScreenMode::YamahaGraphics5) {
@ -326,16 +326,18 @@ void Base<personality>::draw_yamaha(LineBuffer &buffer, int start, int end) {
buffer.bitmap[c >> 2] >> ((((c & 3) ^ 3) << 1)) & 3 buffer.bitmap[c >> 2] >> ((((c & 3) ^ 3) << 1)) & 3
]; ];
} }
return;
} }
draw_sprites<
SpriteMode::Mode2,
mode == ScreenMode::YamahaGraphics5 || mode == ScreenMode::YamahaGraphics6
>(buffer, start, end);
} }
template <Personality personality> template <Personality personality>
void Base<personality>::draw_yamaha(int start, int end) { void Base<personality>::draw_yamaha(int start, int end) {
LineBuffer &line_buffer = line_buffers_[output_pointer_.row]; LineBuffer &line_buffer = line_buffers_[output_pointer_.row];
#define Dispatch(x) case ScreenMode::x: draw_yamaha<ScreenMode::x>(line_buffer, start, end); break;
if constexpr (is_yamaha_vdp(personality)) { if constexpr (is_yamaha_vdp(personality)) {
switch(line_buffer.screen_mode) { switch(line_buffer.screen_mode) {
// Modes that are the same (or close enough) to those on the TMS. // Modes that are the same (or close enough) to those on the TMS.
@ -343,18 +345,22 @@ void Base<personality>::draw_yamaha(int start, int end) {
case ScreenMode::YamahaText80: draw_tms_text<true>(start >> 1, end >> 1); break; case ScreenMode::YamahaText80: draw_tms_text<true>(start >> 1, end >> 1); break;
case ScreenMode::MultiColour: case ScreenMode::MultiColour:
case ScreenMode::ColouredText: case ScreenMode::ColouredText:
case ScreenMode::YamahaGraphics3: // TODO: does this make sense?3
case ScreenMode::Graphics: draw_tms_character(start >> 2, end >> 2); break; case ScreenMode::Graphics: draw_tms_character(start >> 2, end >> 2); break;
// Dispatch(YamahaGraphics3); case ScreenMode::YamahaGraphics3:
draw_tms_character<SpriteMode::Mode2>(start >> 2, end >> 2);
break;
#define Dispatch(x) case ScreenMode::x: draw_yamaha<ScreenMode::x>(line_buffer, start, end); break;
Dispatch(YamahaGraphics4); Dispatch(YamahaGraphics4);
Dispatch(YamahaGraphics5); Dispatch(YamahaGraphics5);
Dispatch(YamahaGraphics6); Dispatch(YamahaGraphics6);
Dispatch(YamahaGraphics7); Dispatch(YamahaGraphics7);
#undef Dispatch
default: break; default: break;
} }
} }
#undef Dispatch
} }
// MARK: - Mega Drive // MARK: - Mega Drive

11
Components/9918/Implementation/Fetch.hpp
View File

@ -173,12 +173,6 @@ struct CharacterFetcher {
int colour_name_shift; int colour_name_shift;
}; };
enum class SpriteMode {
Mode1,
Mode2,
// MasterSystem,
};
constexpr SpriteMode sprite_mode(ScreenMode screen_mode) { constexpr SpriteMode sprite_mode(ScreenMode screen_mode) {
switch(screen_mode) { switch(screen_mode) {
default: default:
@ -189,11 +183,12 @@ constexpr SpriteMode sprite_mode(ScreenMode screen_mode) {
case ScreenMode::Graphics: case ScreenMode::Graphics:
return SpriteMode::Mode1; return SpriteMode::Mode1;
// case ScreenMode::SMSMode4: case ScreenMode::SMSMode4:
// return SpriteMode::MasterSystem; return SpriteMode::MasterSystem;
} }
} }
// TODO: should this be extended to include Master System sprites?
template <Personality personality, SpriteMode mode> template <Personality personality, SpriteMode mode>
class SpriteFetcher { class SpriteFetcher {
public: public: