Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-13 09:28:13 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #2384 from npwoods/coco3_gime_cleanups

Browse Source 
[CoCo 3]  Cleanups to the GIME implementation
This commit is contained in:
hap 2017-06-18 16:49:08 +02:00 committed by GitHub
commit 6582ec8a93
4 changed files with 162 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/mame/drivers/coco3.cpp
View File

@ -44,7 +44,7 @@ static ADDRESS_MAP_START( coco3_mem, AS_PROGRAM, 8, coco3_state )
AM_RANGE(0xFF20, 0xFF3F) AM_READWRITE(ff20_read, ff20_write) AM_RANGE(0xFF20, 0xFF3F) AM_READWRITE(ff20_read, ff20_write)
AM_RANGE(0xFF40, 0xFF5F) AM_READWRITE(ff40_read, ff40_write) AM_RANGE(0xFF40, 0xFF5F) AM_READWRITE(ff40_read, ff40_write)
AM_RANGE(0xFF60, 0xFF8F) AM_READWRITE(ff60_read, ff60_write) AM_RANGE(0xFF60, 0xFF8F) AM_READWRITE(ff60_read, ff60_write)
AM_RANGE(0xFF90, 0xFFDF) AM_DEVREADWRITE(GIME_TAG, gime_base_device, read, write) AM_RANGE(0xFF90, 0xFFDF) AM_DEVREADWRITE(GIME_TAG, gime_device, read, write)
// While Tepolt and other sources say that the interrupt vectors are mapped to // While Tepolt and other sources say that the interrupt vectors are mapped to
// the same memory accessed at $BFFx, William Astle offered evidence that this // the same memory accessed at $BFFx, William Astle offered evidence that this

2
src/mame/includes/coco3.h
View File

@ -61,7 +61,7 @@ protected:
virtual void cart_w(bool line) override; virtual void cart_w(bool line) override;
private: private:
required_device<gime_base_device> m_gime; required_device<gime_device> m_gime;
}; };
#endif // MAME_INCLUDES_COCO3_H #endif // MAME_INCLUDES_COCO3_H

281
src/mame/video/gime.cpp
View File

@ -2,7 +2,7 @@
// copyright-holders:Nathan Woods // copyright-holders:Nathan Woods
/********************************************************************* /*********************************************************************
gime.c gime.cpp
Implementation of CoCo GIME (Graphics Interrupt Memory Enhancement) Implementation of CoCo GIME (Graphics Interrupt Memory Enhancement)
video chip. video chip.
@ -108,14 +108,14 @@
// ctor // ctor
//------------------------------------------------- //-------------------------------------------------
gime_base_device::gime_base_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, const uint8_t *fontdata) gime_device::gime_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, const uint8_t *fontdata)
: mc6847_friend_device(mconfig, type, tag, owner, clock, fontdata, true, 263, 25+192+26+3, false), : mc6847_friend_device(mconfig, type, tag, owner, clock, fontdata, true, 263, 25+192+26+3, false)
m_write_irq(*this), , m_write_irq(*this)
m_write_firq(*this), , m_write_firq(*this)
m_read_floating_bus(*this), , m_read_floating_bus(*this)
m_maincpu_tag(nullptr), , m_maincpu_tag(nullptr)
m_ram_tag(nullptr), , m_ram_tag(nullptr)
m_ext_tag(nullptr) , m_ext_tag(nullptr)
{ {
} }
@ -125,7 +125,7 @@ gime_base_device::gime_base_device(const machine_config &mconfig, device_type ty
// device_start - device-specific startup // device_start - device-specific startup
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::device_start(void) void gime_device::device_start(void)
{ {
// find the RAM device - make sure that it is started // find the RAM device - make sure that it is started
m_ram = machine().device<ram_device>(m_ram_tag); m_ram = machine().device<ram_device>(m_ram_tag);
@ -198,7 +198,7 @@ void gime_base_device::device_start(void)
// update_rgb_palette // update_rgb_palette
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::update_rgb_palette(void) void gime_device::update_rgb_palette(void)
{ {
for (int color = 0; color < 64; color++) for (int color = 0; color < 64; color++)
{ {
@ -212,7 +212,7 @@ void gime_base_device::update_rgb_palette(void)
// update_composite_palette // update_composite_palette
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::update_composite_palette(void) void gime_device::update_composite_palette(void)
{ {
for (int color = 0; color < 64; color++) for (int color = 0; color < 64; color++)
{ {
@ -227,7 +227,7 @@ void gime_base_device::update_composite_palette(void)
// get_composite_color // get_composite_color
//------------------------------------------------- //-------------------------------------------------
inline gime_base_device::pixel_t gime_base_device::get_composite_color(int color) inline gime_device::pixel_t gime_device::get_composite_color(int color)
{ {
static pixel_t composite_palette[64] = { static pixel_t composite_palette[64] = {
0x000000, 0x004c00, 0x004300, 0x0a3100, 0x2f1b00, 0x550100, 0x6c0000, 0x770006, 0x000000, 0x004c00, 0x004300, 0x0a3100, 0x2f1b00, 0x550100, 0x6c0000, 0x770006,
@ -261,7 +261,7 @@ inline gime_base_device::pixel_t gime_base_device::get_composite_color(int color
// get_rgb_color // get_rgb_color
//------------------------------------------------- //-------------------------------------------------
inline gime_base_device::pixel_t gime_base_device::get_rgb_color(int color) inline gime_device::pixel_t gime_device::get_rgb_color(int color)
{ {
return (((color >> 4) & 2) | ((color >> 2) & 1)) * 0x550000 return (((color >> 4) & 2) | ((color >> 2) & 1)) * 0x550000
| (((color >> 3) & 2) | ((color >> 1) & 1)) * 0x005500 | (((color >> 3) & 2) | ((color >> 1) & 1)) * 0x005500
@ -274,7 +274,7 @@ inline gime_base_device::pixel_t gime_base_device::get_rgb_color(int color)
// device_reset - device-specific reset // device_reset - device-specific reset
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::device_reset(void) void gime_device::device_reset(void)
{ {
/* Tepolt verifies that the GIME registers are all cleared on initialization */ /* Tepolt verifies that the GIME registers are all cleared on initialization */
memset(m_gime_registers, 0, sizeof(m_gime_registers)); memset(m_gime_registers, 0, sizeof(m_gime_registers));
@ -311,7 +311,7 @@ void gime_base_device::device_reset(void)
// device_timer - handle timer callbacks // device_timer - handle timer callbacks
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) void gime_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{ {
switch(id) switch(id)
{ {
@ -331,7 +331,7 @@ void gime_base_device::device_timer(emu_timer &timer, device_timer_id id, int pa
// device_pre_save - device-specific pre save // device_pre_save - device-specific pre save
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::device_pre_save() void gime_device::device_pre_save()
{ {
super::device_pre_save(); super::device_pre_save();
@ -345,7 +345,7 @@ void gime_base_device::device_pre_save()
// device_post_load - device-specific post load // device_post_load - device-specific post load
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::device_post_load() void gime_device::device_post_load()
{ {
super::device_post_load(); super::device_post_load();
update_memory(); update_memory();
@ -362,7 +362,7 @@ void gime_base_device::device_post_load()
// device_input_ports // device_input_ports
//------------------------------------------------- //-------------------------------------------------
ioport_constructor gime_base_device::device_input_ports() const ioport_constructor gime_device::device_input_ports() const
{ {
return INPUT_PORTS_NAME(mc6847_artifacting); return INPUT_PORTS_NAME(mc6847_artifacting);
} }
@ -394,7 +394,7 @@ ioport_constructor gime_base_device::device_input_ports() const
// timer_type // timer_type
//------------------------------------------------- //-------------------------------------------------
gime_base_device::timer_type_t gime_base_device::timer_type(void) gime_device::timer_type_t gime_device::timer_type(void)
{ {
// wraps the GIME register access and returns an enumeration // wraps the GIME register access and returns an enumeration
return (m_gime_registers[0x01] & 0x20) ? GIME_TIMER_CLOCK : GIME_TIMER_HBORD; return (m_gime_registers[0x01] & 0x20) ? GIME_TIMER_CLOCK : GIME_TIMER_HBORD;
@ -406,7 +406,7 @@ gime_base_device::timer_type_t gime_base_device::timer_type(void)
// timer_type_string // timer_type_string
//------------------------------------------------- //-------------------------------------------------
const char *gime_base_device::timer_type_string(void) const char *gime_device::timer_type_string(void)
{ {
const char *result; const char *result;
switch(timer_type()) switch(timer_type())
@ -429,7 +429,7 @@ const char *gime_base_device::timer_type_string(void)
// timer_elapsed // timer_elapsed
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::timer_elapsed(void) void gime_device::timer_elapsed(void)
{ {
/* reset the timer; give her another run! */ /* reset the timer; give her another run! */
reset_timer(); reset_timer();
@ -448,7 +448,7 @@ void gime_base_device::timer_elapsed(void)
// reset_timer // reset_timer
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::reset_timer(void) void gime_device::reset_timer(void)
{ {
/* value is from 0-4095 */ /* value is from 0-4095 */
m_timer_value = ((m_gime_registers[0x04] & 0x0F) * 0x100) | m_gime_registers[0x05]; m_timer_value = ((m_gime_registers[0x04] & 0x0F) * 0x100) | m_gime_registers[0x05];
@ -491,7 +491,7 @@ void gime_base_device::reset_timer(void)
// update_memory // update_memory
//------------------------------------------------- //-------------------------------------------------
inline void gime_base_device::update_memory(void) inline void gime_device::update_memory(void)
{ {
for (int bank = 0; bank <= 8; bank++) for (int bank = 0; bank <= 8; bank++)
{ {
@ -505,7 +505,7 @@ inline void gime_base_device::update_memory(void)
// update_memory // update_memory
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::update_memory(int bank) void gime_device::update_memory(int bank)
{ {
// choose bank // choose bank
assert((bank >= 0) && (bank < ARRAY_LENGTH(m_read_banks)) && (bank < ARRAY_LENGTH(m_write_banks))); assert((bank >= 0) && (bank < ARRAY_LENGTH(m_read_banks)) && (bank < ARRAY_LENGTH(m_write_banks)));
@ -594,7 +594,7 @@ void gime_base_device::update_memory(int bank)
// memory_pointer // memory_pointer
//------------------------------------------------- //-------------------------------------------------
uint8_t *gime_base_device::memory_pointer(uint32_t address) uint8_t *gime_device::memory_pointer(uint32_t address)
{ {
return &m_ram->pointer()[address % m_ram->size()]; return &m_ram->pointer()[address % m_ram->size()];
} }
@ -605,7 +605,7 @@ uint8_t *gime_base_device::memory_pointer(uint32_t address)
// update_cart_rom // update_cart_rom
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::update_cart_rom(void) void gime_device::update_cart_rom(void)
{ {
m_cart_rom = m_cart_device->get_cart_base(); m_cart_rom = m_cart_device->get_cart_base();
update_memory(); update_memory();
@ -617,7 +617,7 @@ void gime_base_device::update_cart_rom(void)
// read // read
//------------------------------------------------- //-------------------------------------------------
uint8_t gime_base_device::read(offs_t offset) uint8_t gime_device::read(offs_t offset)
{ {
uint8_t data = 0x00; uint8_t data = 0x00;
@ -649,7 +649,7 @@ uint8_t gime_base_device::read(offs_t offset)
// read_gime_register // read_gime_register
//------------------------------------------------- //-------------------------------------------------
inline uint8_t gime_base_device::read_gime_register(offs_t offset) inline uint8_t gime_device::read_gime_register(offs_t offset)
{ {
offset &= 0x0F; offset &= 0x0F;
@ -688,7 +688,7 @@ inline uint8_t gime_base_device::read_gime_register(offs_t offset)
// read_mmu_register // read_mmu_register
//------------------------------------------------- //-------------------------------------------------
inline uint8_t gime_base_device::read_mmu_register(offs_t offset) inline uint8_t gime_device::read_mmu_register(offs_t offset)
{ {
return (m_mmu[offset & 0x0F] & 0x3F) | (read_floating_bus() & 0xC0); return (m_mmu[offset & 0x0F] & 0x3F) | (read_floating_bus() & 0xC0);
} }
@ -699,7 +699,7 @@ inline uint8_t gime_base_device::read_mmu_register(offs_t offset)
// read_palette_register // read_palette_register
//------------------------------------------------- //-------------------------------------------------
inline uint8_t gime_base_device::read_palette_register(offs_t offset) inline uint8_t gime_device::read_palette_register(offs_t offset)
{ {
// Bits 7/6 are floating, and behave oddly. On a real CoCo 3 // Bits 7/6 are floating, and behave oddly. On a real CoCo 3
// //
@ -717,7 +717,7 @@ inline uint8_t gime_base_device::read_palette_register(offs_t offset)
// read_floating_bus // read_floating_bus
//------------------------------------------------- //-------------------------------------------------
inline uint8_t gime_base_device::read_floating_bus(void) inline uint8_t gime_device::read_floating_bus(void)
{ {
return m_read_floating_bus(0); return m_read_floating_bus(0);
} }
@ -728,7 +728,7 @@ inline uint8_t gime_base_device::read_floating_bus(void)
// write // write
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::write(offs_t offset, uint8_t data) void gime_device::write(offs_t offset, uint8_t data)
{ {
switch(offset & 0xF0) switch(offset & 0xF0)
{ {
@ -757,7 +757,7 @@ void gime_base_device::write(offs_t offset, uint8_t data)
// write_gime_register // write_gime_register
//------------------------------------------------- //-------------------------------------------------
inline void gime_base_device::write_gime_register(offs_t offset, uint8_t data) inline void gime_device::write_gime_register(offs_t offset, uint8_t data)
{ {
// this is needed for writes to FF95 // this is needed for writes to FF95
bool timer_was_off = (m_gime_registers[0x04] == 0x00) && (m_gime_registers[0x05] == 0x00); bool timer_was_off = (m_gime_registers[0x04] == 0x00) && (m_gime_registers[0x05] == 0x00);
@ -980,7 +980,7 @@ inline void gime_base_device::write_gime_register(offs_t offset, uint8_t data)
// write_mmu_register // write_mmu_register
//------------------------------------------------- //-------------------------------------------------
inline void gime_base_device::write_mmu_register(offs_t offset, uint8_t data) inline void gime_device::write_mmu_register(offs_t offset, uint8_t data)
{ {
offset &= 0x0F; offset &= 0x0F;
@ -1000,7 +1000,7 @@ inline void gime_base_device::write_mmu_register(offs_t offset, uint8_t data)
// write_palette_register // write_palette_register
//------------------------------------------------- //-------------------------------------------------
inline void gime_base_device::write_palette_register(offs_t offset, uint8_t data) inline void gime_device::write_palette_register(offs_t offset, uint8_t data)
{ {
offset &= 0x0F; offset &= 0x0F;
@ -1033,7 +1033,7 @@ inline void gime_base_device::write_palette_register(offs_t offset, uint8_t data
// write_sam_register // write_sam_register
//------------------------------------------------- //-------------------------------------------------
inline void gime_base_device::write_sam_register(offs_t offset) inline void gime_device::write_sam_register(offs_t offset)
{ {
/* change the SAM state */ /* change the SAM state */
uint16_t xorval = alter_sam_state(offset); uint16_t xorval = alter_sam_state(offset);
@ -1051,7 +1051,7 @@ inline void gime_base_device::write_sam_register(offs_t offset)
// interrupt_rising_edge // interrupt_rising_edge
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::interrupt_rising_edge(uint8_t interrupt) void gime_device::interrupt_rising_edge(uint8_t interrupt)
{ {
// evaluate IRQ // evaluate IRQ
if ((m_gime_registers[0x00] & 0x20) && (m_gime_registers[0x02] & interrupt)) if ((m_gime_registers[0x00] & 0x20) && (m_gime_registers[0x02] & interrupt))
@ -1067,7 +1067,7 @@ void gime_base_device::interrupt_rising_edge(uint8_t interrupt)
// change_gime_irq // change_gime_irq
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::change_gime_irq(uint8_t data) void gime_device::change_gime_irq(uint8_t data)
{ {
// did the value actually change? // did the value actually change?
if (m_irq != data) if (m_irq != data)
@ -1082,7 +1082,7 @@ void gime_base_device::change_gime_irq(uint8_t data)
// change_gime_firq // change_gime_firq
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::change_gime_firq(uint8_t data) void gime_device::change_gime_firq(uint8_t data)
{ {
// did the value actually change? // did the value actually change?
if (m_firq != data) if (m_firq != data)
@ -1107,7 +1107,7 @@ void gime_base_device::change_gime_firq(uint8_t data)
// John Kowalski confirms this behavior // John Kowalski confirms this behavior
//------------------------------------------------- //-------------------------------------------------
inline offs_t gime_base_device::get_video_base(void) inline offs_t gime_device::get_video_base(void)
{ {
offs_t result; offs_t result;
uint8_t ff9d_mask, ff9e_mask; uint8_t ff9d_mask, ff9e_mask;
@ -1139,7 +1139,7 @@ inline offs_t gime_base_device::get_video_base(void)
// new_frame // new_frame
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::new_frame(void) void gime_device::new_frame(void)
{ {
/* call inherited function */ /* call inherited function */
super::new_frame(); super::new_frame();
@ -1162,7 +1162,7 @@ void gime_base_device::new_frame(void)
// horizontal_sync_changed // horizontal_sync_changed
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::horizontal_sync_changed(bool line) void gime_device::horizontal_sync_changed(bool line)
{ {
set_interrupt_value(INTERRUPT_HBORD, line); set_interrupt_value(INTERRUPT_HBORD, line);
@ -1181,7 +1181,7 @@ void gime_base_device::horizontal_sync_changed(bool line)
// enter_bottom_border // enter_bottom_border
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::enter_bottom_border(void) void gime_device::enter_bottom_border(void)
{ {
set_interrupt_value(INTERRUPT_VBORD, true); set_interrupt_value(INTERRUPT_VBORD, true);
set_interrupt_value(INTERRUPT_VBORD, false); set_interrupt_value(INTERRUPT_VBORD, false);
@ -1193,7 +1193,7 @@ void gime_base_device::enter_bottom_border(void)
// update_border // update_border
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::update_border(uint16_t physical_scanline) void gime_device::update_border(uint16_t physical_scanline)
{ {
uint8_t border; uint8_t border;
if (m_legacy_video) if (m_legacy_video)
@ -1231,7 +1231,7 @@ void gime_base_device::update_border(uint16_t physical_scanline)
// record_border_scanline // record_border_scanline
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::record_border_scanline(uint16_t physical_scanline) void gime_device::record_border_scanline(uint16_t physical_scanline)
{ {
m_line_in_row = 0; m_line_in_row = 0;
update_border(physical_scanline); update_border(physical_scanline);
@ -1244,7 +1244,7 @@ void gime_base_device::record_border_scanline(uint16_t physical_scanline)
// get_lines_per_row // get_lines_per_row
//------------------------------------------------- //-------------------------------------------------
inline uint16_t gime_base_device::get_lines_per_row(void) inline uint16_t gime_device::get_lines_per_row(void)
{ {
uint16_t lines_per_row; uint16_t lines_per_row;
if (m_legacy_video) if (m_legacy_video)
@ -1332,8 +1332,8 @@ inline uint16_t gime_base_device::get_lines_per_row(void)
// record_scanline_res // record_scanline_res
//------------------------------------------------- //-------------------------------------------------
template<uint8_t xres, gime_base_device::get_data_func get_data, bool record_mode> template<uint8_t xres, gime_device::get_data_func get_data, bool record_mode>
inline uint32_t gime_base_device::record_scanline_res(int scanline) inline uint32_t gime_device::record_scanline_res(int scanline)
{ {
int column; int column;
uint32_t base_offset = m_legacy_video ? 0 : (m_gime_registers[0x0F] & 0x7F) * 2; uint32_t base_offset = m_legacy_video ? 0 : (m_gime_registers[0x0F] & 0x7F) * 2;
@ -1363,7 +1363,7 @@ inline uint32_t gime_base_device::record_scanline_res(int scanline)
// in legacy video modes // in legacy video modes
//------------------------------------------------- //-------------------------------------------------
uint32_t gime_base_device::get_data_mc6847(uint32_t video_position, uint8_t *data, uint8_t *mode) uint32_t gime_device::get_data_mc6847(uint32_t video_position, uint8_t *data, uint8_t *mode)
{ {
*data = *memory_pointer(video_position); *data = *memory_pointer(video_position);
*mode = (m_ff22_value & (MODE_AG|MODE_GM2|MODE_GM1|MODE_GM0|MODE_CSS)) *mode = (m_ff22_value & (MODE_AG|MODE_GM2|MODE_GM1|MODE_GM0|MODE_CSS))
@ -1383,7 +1383,7 @@ uint32_t gime_base_device::get_data_mc6847(uint32_t video_position, uint8_t *dat
// text modes without attributes // text modes without attributes
//------------------------------------------------- //-------------------------------------------------
uint32_t gime_base_device::get_data_without_attributes(uint32_t video_position, uint8_t *data, uint8_t *mode) uint32_t gime_device::get_data_without_attributes(uint32_t video_position, uint8_t *data, uint8_t *mode)
{ {
*data = *memory_pointer(video_position); *data = *memory_pointer(video_position);
*mode = NO_ATTRIBUTE; *mode = NO_ATTRIBUTE;
@ -1397,7 +1397,7 @@ uint32_t gime_base_device::get_data_without_attributes(uint32_t video_position,
// data/mode in GIME text modes with attributes // data/mode in GIME text modes with attributes
//------------------------------------------------- //-------------------------------------------------
uint32_t gime_base_device::get_data_with_attributes(uint32_t video_position, uint8_t *data, uint8_t *mode) uint32_t gime_device::get_data_with_attributes(uint32_t video_position, uint8_t *data, uint8_t *mode)
{ {
*data = *memory_pointer(video_position + 0); *data = *memory_pointer(video_position + 0);
*mode = *memory_pointer(video_position + 1); *mode = *memory_pointer(video_position + 1);
@ -1424,7 +1424,7 @@ uint32_t gime_base_device::get_data_with_attributes(uint32_t video_position, uin
// record_body_scanline // record_body_scanline
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::record_body_scanline(uint16_t physical_scanline, uint16_t logical_scanline) void gime_device::record_body_scanline(uint16_t physical_scanline, uint16_t logical_scanline)
{ {
/* update the border first */ /* update the border first */
update_border(physical_scanline); update_border(physical_scanline);
@ -1447,7 +1447,7 @@ void gime_base_device::record_body_scanline(uint16_t physical_scanline, uint16_t
case MODE_AG|MODE_GM0: case MODE_AG|MODE_GM0:
case MODE_AG|MODE_GM1|MODE_GM0: case MODE_AG|MODE_GM1|MODE_GM0:
case MODE_AG|MODE_GM2|MODE_GM0: case MODE_AG|MODE_GM2|MODE_GM0:
pitch = record_scanline_res<16, &gime_base_device::get_data_mc6847, true>(physical_scanline); pitch = record_scanline_res<16, &gime_device::get_data_mc6847, true>(physical_scanline);
break; break;
case 0: case 0:
@ -1462,7 +1462,7 @@ void gime_base_device::record_body_scanline(uint16_t physical_scanline, uint16_t
case MODE_AG|MODE_GM2: case MODE_AG|MODE_GM2:
case MODE_AG|MODE_GM2|MODE_GM1: case MODE_AG|MODE_GM2|MODE_GM1:
case MODE_AG|MODE_GM2|MODE_GM1|MODE_GM0: case MODE_AG|MODE_GM2|MODE_GM1|MODE_GM0:
pitch = record_scanline_res<32, &gime_base_device::get_data_mc6847, true>(physical_scanline); pitch = record_scanline_res<32, &gime_device::get_data_mc6847, true>(physical_scanline);
break; break;
default: default:
@ -1482,14 +1482,14 @@ void gime_base_device::record_body_scanline(uint16_t physical_scanline, uint16_t
/* graphics */ /* graphics */
switch(m_gime_registers[0x09] & 0x1C) switch(m_gime_registers[0x09] & 0x1C)
{ {
case 0x00: pitch = record_scanline_res< 16, &gime_base_device::get_data_without_attributes, false>(physical_scanline); break; case 0x00: pitch = record_scanline_res< 16, &gime_device::get_data_without_attributes, false>(physical_scanline); break;
case 0x04: pitch = record_scanline_res< 20, &gime_base_device::get_data_without_attributes, false>(physical_scanline); break; case 0x04: pitch = record_scanline_res< 20, &gime_device::get_data_without_attributes, false>(physical_scanline); break;
case 0x08: pitch = record_scanline_res< 32, &gime_base_device::get_data_without_attributes, false>(physical_scanline); break; case 0x08: pitch = record_scanline_res< 32, &gime_device::get_data_without_attributes, false>(physical_scanline); break;
case 0x0C: pitch = record_scanline_res< 40, &gime_base_device::get_data_without_attributes, false>(physical_scanline); break; case 0x0C: pitch = record_scanline_res< 40, &gime_device::get_data_without_attributes, false>(physical_scanline); break;
case 0x10: pitch = record_scanline_res< 64, &gime_base_device::get_data_without_attributes, false>(physical_scanline); break; case 0x10: pitch = record_scanline_res< 64, &gime_device::get_data_without_attributes, false>(physical_scanline); break;
case 0x14: pitch = record_scanline_res< 80, &gime_base_device::get_data_without_attributes, false>(physical_scanline); break; case 0x14: pitch = record_scanline_res< 80, &gime_device::get_data_without_attributes, false>(physical_scanline); break;
case 0x18: pitch = record_scanline_res<128, &gime_base_device::get_data_without_attributes, false>(physical_scanline); break; case 0x18: pitch = record_scanline_res<128, &gime_device::get_data_without_attributes, false>(physical_scanline); break;
case 0x1C: pitch = record_scanline_res<160, &gime_base_device::get_data_without_attributes, false>(physical_scanline); break; case 0x1C: pitch = record_scanline_res<160, &gime_device::get_data_without_attributes, false>(physical_scanline); break;
default: default:
fatalerror("Should not get here\n"); fatalerror("Should not get here\n");
} }
@ -1499,14 +1499,14 @@ void gime_base_device::record_body_scanline(uint16_t physical_scanline, uint16_t
/* text */ /* text */
switch(m_gime_registers[0x09] & 0x15) switch(m_gime_registers[0x09] & 0x15)
{ {
case 0x00: pitch = record_scanline_res< 32, &gime_base_device::get_data_without_attributes, true>(physical_scanline); break; case 0x00: pitch = record_scanline_res< 32, &gime_device::get_data_without_attributes, true>(physical_scanline); break;
case 0x01: pitch = record_scanline_res< 32, &gime_base_device::get_data_with_attributes, true>(physical_scanline); break; case 0x01: pitch = record_scanline_res< 32, &gime_device::get_data_with_attributes, true>(physical_scanline); break;
case 0x04: pitch = record_scanline_res< 40, &gime_base_device::get_data_without_attributes, true>(physical_scanline); break; case 0x04: pitch = record_scanline_res< 40, &gime_device::get_data_without_attributes, true>(physical_scanline); break;
case 0x05: pitch = record_scanline_res< 40, &gime_base_device::get_data_with_attributes, true>(physical_scanline); break; case 0x05: pitch = record_scanline_res< 40, &gime_device::get_data_with_attributes, true>(physical_scanline); break;
case 0x10: pitch = record_scanline_res< 64, &gime_base_device::get_data_without_attributes, true>(physical_scanline); break; case 0x10: pitch = record_scanline_res< 64, &gime_device::get_data_without_attributes, true>(physical_scanline); break;
case 0x11: pitch = record_scanline_res< 64, &gime_base_device::get_data_with_attributes, true>(physical_scanline); break; case 0x11: pitch = record_scanline_res< 64, &gime_device::get_data_with_attributes, true>(physical_scanline); break;
case 0x14: pitch = record_scanline_res< 80, &gime_base_device::get_data_without_attributes, true>(physical_scanline); break; case 0x14: pitch = record_scanline_res< 80, &gime_device::get_data_without_attributes, true>(physical_scanline); break;
case 0x15: pitch = record_scanline_res< 80, &gime_base_device::get_data_with_attributes, true>(physical_scanline); break; case 0x15: pitch = record_scanline_res< 80, &gime_device::get_data_with_attributes, true>(physical_scanline); break;
default: default:
fatalerror("Should not get here\n"); fatalerror("Should not get here\n");
} }
@ -1537,7 +1537,7 @@ void gime_base_device::record_body_scanline(uint16_t physical_scanline, uint16_t
// record_partial_body_scanline // record_partial_body_scanline
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::record_partial_body_scanline(uint16_t physical_scanline, uint16_t logical_scanline, int32_t start_clock, int32_t end_clock) void gime_device::record_partial_body_scanline(uint16_t physical_scanline, uint16_t logical_scanline, int32_t start_clock, int32_t end_clock)
{ {
fatalerror("NYI"); fatalerror("NYI");
} }
@ -1548,7 +1548,7 @@ void gime_base_device::record_partial_body_scanline(uint16_t physical_scanline,
// update_geometry // update_geometry
//------------------------------------------------- //-------------------------------------------------
void gime_base_device::update_geometry(void) void gime_device::update_geometry(void)
{ {
uint16_t top_border_scanlines, body_scanlines; uint16_t top_border_scanlines, body_scanlines;
@ -1602,7 +1602,7 @@ void gime_base_device::update_geometry(void)
// emit_dummy_samples // emit_dummy_samples
//------------------------------------------------- //-------------------------------------------------
uint32_t gime_base_device::emit_dummy_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette) uint32_t gime_device::emit_dummy_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette)
{ {
fatalerror("Should not get here\n"); fatalerror("Should not get here\n");
} }
@ -1611,7 +1611,7 @@ uint32_t gime_base_device::emit_dummy_samples(const scanline_record *scanline, i
// emit_mc6847_samples // emit_mc6847_samples
//------------------------------------------------- //-------------------------------------------------
inline uint32_t gime_base_device::emit_mc6847_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette) inline uint32_t gime_device::emit_mc6847_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette)
{ {
return super::emit_mc6847_samples<2>( return super::emit_mc6847_samples<2>(
scanline->m_mode[sample_start], scanline->m_mode[sample_start],
@ -1631,7 +1631,7 @@ inline uint32_t gime_base_device::emit_mc6847_samples(const scanline_record *sca
//------------------------------------------------- //-------------------------------------------------
template<int xscale, int bits_per_pixel> template<int xscale, int bits_per_pixel>
inline uint32_t gime_base_device::emit_gime_graphics_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette) inline uint32_t gime_device::emit_gime_graphics_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette)
{ {
const uint8_t *data = &scanline->m_data[sample_start]; const uint8_t *data = &scanline->m_data[sample_start];
mc6847_friend_device::emit_graphics<bits_per_pixel, xscale>(data, sample_count, pixels, 0, palette); mc6847_friend_device::emit_graphics<bits_per_pixel, xscale>(data, sample_count, pixels, 0, palette);
@ -1645,7 +1645,7 @@ inline uint32_t gime_base_device::emit_gime_graphics_samples(const scanline_reco
//------------------------------------------------- //-------------------------------------------------
template<int xscale> template<int xscale>
inline uint32_t gime_base_device::emit_gime_text_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette) inline uint32_t gime_device::emit_gime_text_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette)
{ {
uint8_t attribute = scanline->m_mode[sample_start]; uint8_t attribute = scanline->m_mode[sample_start];
const uint8_t *data = &scanline->m_data[sample_start]; const uint8_t *data = &scanline->m_data[sample_start];
@ -1704,8 +1704,8 @@ inline uint32_t gime_base_device::emit_gime_text_samples(const scanline_record *
// render_scanline // render_scanline
//------------------------------------------------- //-------------------------------------------------
template<int sample_count, gime_base_device::emit_samples_proc emit_samples> template<int sample_count, gime_device::emit_samples_proc emit_samples>
inline void gime_base_device::render_scanline(const scanline_record *scanline, pixel_t *pixels, int min_x, int max_x, palette_resolver *resolver) inline void gime_device::render_scanline(const scanline_record *scanline, pixel_t *pixels, int min_x, int max_x, palette_resolver *resolver)
{ {
int left_border, right_border; int left_border, right_border;
int x, x2, pixel_position; int x, x2, pixel_position;
@ -1774,14 +1774,14 @@ inline void gime_base_device::render_scanline(const scanline_record *scanline, p
// update_screen // update_screen
//------------------------------------------------- //-------------------------------------------------
bool gime_base_device::update_screen(bitmap_rgb32 &bitmap, const rectangle &cliprect, const pixel_t *RESTRICT palette) bool gime_device::update_screen(bitmap_rgb32 &bitmap, const rectangle &cliprect, const pixel_t *RESTRICT palette)
{ {
int base_x = 64; int base_x = 64;
int min_x = USE_HORIZONTAL_CLIP ? cliprect.min_x : 0; int min_x = USE_HORIZONTAL_CLIP ? cliprect.min_x : 0;
int max_x = USE_HORIZONTAL_CLIP ? cliprect.max_x : (base_x * 2 + 512 - 1); int max_x = USE_HORIZONTAL_CLIP ? cliprect.max_x : (base_x * 2 + 512 - 1);
int min_y = cliprect.min_y; int min_y = cliprect.min_y;
int max_y = cliprect.max_y; int max_y = cliprect.max_y;
palette_resolver resolver(this, palette); palette_resolver resolver(*this, palette);
/* if the video didn't change, indicate as much */ /* if the video didn't change, indicate as much */
if (!has_video_changed()) if (!has_video_changed())
@ -1796,7 +1796,7 @@ bool gime_base_device::update_screen(bitmap_rgb32 &bitmap, const rectangle &clip
if (m_scanlines[y].m_line_in_row == (uint8_t) ~0) if (m_scanlines[y].m_line_in_row == (uint8_t) ~0)
{ {
/* this is a border scanline */ /* this is a border scanline */
render_scanline<0, &gime_base_device::emit_dummy_samples>(scanline, pixels, min_x, max_x, &resolver); render_scanline<0, &gime_device::emit_dummy_samples>(scanline, pixels, min_x, max_x, &resolver);
} }
else if (m_legacy_video) else if (m_legacy_video)
{ {
@ -1807,11 +1807,11 @@ bool gime_base_device::update_screen(bitmap_rgb32 &bitmap, const rectangle &clip
case MODE_AG|MODE_GM0: case MODE_AG|MODE_GM0:
case MODE_AG|MODE_GM1|MODE_GM0: case MODE_AG|MODE_GM1|MODE_GM0:
case MODE_AG|MODE_GM2|MODE_GM0: case MODE_AG|MODE_GM2|MODE_GM0:
render_scanline<16, &gime_base_device::emit_mc6847_samples>(scanline, pixels, min_x, max_x, &resolver); render_scanline<16, &gime_device::emit_mc6847_samples>(scanline, pixels, min_x, max_x, &resolver);
break; break;
default: default:
render_scanline<32, &gime_base_device::emit_mc6847_samples>(scanline, pixels, min_x, max_x, &resolver); render_scanline<32, &gime_device::emit_mc6847_samples>(scanline, pixels, min_x, max_x, &resolver);
break; break;
} }
} }
@ -1820,38 +1820,38 @@ bool gime_base_device::update_screen(bitmap_rgb32 &bitmap, const rectangle &clip
/* GIME graphics */ /* GIME graphics */
switch(scanline->m_ff99_value & 0x1F) switch(scanline->m_ff99_value & 0x1F)
{ {
case 0x00: render_scanline< 16, &gime_base_device::emit_gime_graphics_samples< 4, 1> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x00: render_scanline< 16, &gime_device::emit_gime_graphics_samples< 4, 1> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x01: render_scanline< 16, &gime_base_device::emit_gime_graphics_samples< 8, 2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x01: render_scanline< 16, &gime_device::emit_gime_graphics_samples< 8, 2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x02: case 0x02:
case 0x03: render_scanline< 16, &gime_base_device::emit_gime_graphics_samples<16, 4> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x03: render_scanline< 16, &gime_device::emit_gime_graphics_samples<16, 4> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x04: render_scanline< 20, &gime_base_device::emit_gime_graphics_samples< 4, 1> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x04: render_scanline< 20, &gime_device::emit_gime_graphics_samples< 4, 1> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x05: render_scanline< 20, &gime_base_device::emit_gime_graphics_samples< 8, 2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x05: render_scanline< 20, &gime_device::emit_gime_graphics_samples< 8, 2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x06: case 0x06:
case 0x07: render_scanline< 20, &gime_base_device::emit_gime_graphics_samples<16, 4> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x07: render_scanline< 20, &gime_device::emit_gime_graphics_samples<16, 4> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x08: render_scanline< 32, &gime_base_device::emit_gime_graphics_samples< 2, 1> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x08: render_scanline< 32, &gime_device::emit_gime_graphics_samples< 2, 1> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x09: render_scanline< 32, &gime_base_device::emit_gime_graphics_samples< 4, 2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x09: render_scanline< 32, &gime_device::emit_gime_graphics_samples< 4, 2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x0A: case 0x0A:
case 0x0B: render_scanline< 32, &gime_base_device::emit_gime_graphics_samples< 8, 4> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x0B: render_scanline< 32, &gime_device::emit_gime_graphics_samples< 8, 4> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x0C: render_scanline< 40, &gime_base_device::emit_gime_graphics_samples< 2, 1> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x0C: render_scanline< 40, &gime_device::emit_gime_graphics_samples< 2, 1> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x0D: render_scanline< 40, &gime_base_device::emit_gime_graphics_samples< 4, 2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x0D: render_scanline< 40, &gime_device::emit_gime_graphics_samples< 4, 2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x0E: case 0x0E:
case 0x0F: render_scanline< 40, &gime_base_device::emit_gime_graphics_samples< 8, 4> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x0F: render_scanline< 40, &gime_device::emit_gime_graphics_samples< 8, 4> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x10: render_scanline< 64, &gime_base_device::emit_gime_graphics_samples< 1, 1> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x10: render_scanline< 64, &gime_device::emit_gime_graphics_samples< 1, 1> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x11: render_scanline< 64, &gime_base_device::emit_gime_graphics_samples< 2, 2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x11: render_scanline< 64, &gime_device::emit_gime_graphics_samples< 2, 2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x12: case 0x12:
case 0x13: render_scanline< 64, &gime_base_device::emit_gime_graphics_samples< 4, 4> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x13: render_scanline< 64, &gime_device::emit_gime_graphics_samples< 4, 4> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x14: render_scanline< 80, &gime_base_device::emit_gime_graphics_samples< 1, 1> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x14: render_scanline< 80, &gime_device::emit_gime_graphics_samples< 1, 1> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x15: render_scanline< 80, &gime_base_device::emit_gime_graphics_samples< 2, 2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x15: render_scanline< 80, &gime_device::emit_gime_graphics_samples< 2, 2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x16: case 0x16:
case 0x17: render_scanline< 80, &gime_base_device::emit_gime_graphics_samples< 4, 4> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x17: render_scanline< 80, &gime_device::emit_gime_graphics_samples< 4, 4> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x18: case 0x18:
case 0x19: render_scanline<128, &gime_base_device::emit_gime_graphics_samples< 1, 2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x19: render_scanline<128, &gime_device::emit_gime_graphics_samples< 1, 2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x1A: case 0x1A:
case 0x1B: render_scanline<128, &gime_base_device::emit_gime_graphics_samples< 2, 4> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x1B: render_scanline<128, &gime_device::emit_gime_graphics_samples< 2, 4> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x1C: case 0x1C:
case 0x1D: render_scanline<160, &gime_base_device::emit_gime_graphics_samples< 1, 2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x1D: render_scanline<160, &gime_device::emit_gime_graphics_samples< 1, 2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x1E: case 0x1E:
case 0x1F: render_scanline<160, &gime_base_device::emit_gime_graphics_samples< 2, 4> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x1F: render_scanline<160, &gime_device::emit_gime_graphics_samples< 2, 4> >(scanline, pixels, min_x, max_x, &resolver); break;
} }
} }
else else
@ -1859,10 +1859,10 @@ bool gime_base_device::update_screen(bitmap_rgb32 &bitmap, const rectangle &clip
/* GIME text */ /* GIME text */
switch(scanline->m_ff99_value & 0x14) switch(scanline->m_ff99_value & 0x14)
{ {
case 0x00: render_scanline<32, &gime_base_device::emit_gime_text_samples<2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x00: render_scanline<32, &gime_device::emit_gime_text_samples<2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x04: render_scanline<40, &gime_base_device::emit_gime_text_samples<2> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x04: render_scanline<40, &gime_device::emit_gime_text_samples<2> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x10: render_scanline<64, &gime_base_device::emit_gime_text_samples<1> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x10: render_scanline<64, &gime_device::emit_gime_text_samples<1> >(scanline, pixels, min_x, max_x, &resolver); break;
case 0x14: render_scanline<80, &gime_base_device::emit_gime_text_samples<1> >(scanline, pixels, min_x, max_x, &resolver); break; case 0x14: render_scanline<80, &gime_device::emit_gime_text_samples<1> >(scanline, pixels, min_x, max_x, &resolver); break;
} }
} }
} }
@ -1875,7 +1875,7 @@ bool gime_base_device::update_screen(bitmap_rgb32 &bitmap, const rectangle &clip
// update_composite // update_composite
//------------------------------------------------- //-------------------------------------------------
bool gime_base_device::update_composite(bitmap_rgb32 &bitmap, const rectangle &cliprect) bool gime_device::update_composite(bitmap_rgb32 &bitmap, const rectangle &cliprect)
{ {
update_value(&m_displayed_rgb, false); update_value(&m_displayed_rgb, false);
const pixel_t *palette = (m_gime_registers[0x08] & 0x10) const pixel_t *palette = (m_gime_registers[0x08] & 0x10)
@ -1890,7 +1890,7 @@ bool gime_base_device::update_composite(bitmap_rgb32 &bitmap, const rectangle &c
// update_rgb // update_rgb
//------------------------------------------------- //-------------------------------------------------
bool gime_base_device::update_rgb(bitmap_rgb32 &bitmap, const rectangle &cliprect) bool gime_device::update_rgb(bitmap_rgb32 &bitmap, const rectangle &cliprect)
{ {
update_value(&m_displayed_rgb, true); update_value(&m_displayed_rgb, true);
return update_screen(bitmap, cliprect, m_rgb_palette); return update_screen(bitmap, cliprect, m_rgb_palette);
@ -1906,10 +1906,10 @@ bool gime_base_device::update_rgb(bitmap_rgb32 &bitmap, const rectangle &cliprec
// palette_resolver::palette_resolver // palette_resolver::palette_resolver
//------------------------------------------------- //-------------------------------------------------
inline gime_base_device::palette_resolver::palette_resolver(gime_base_device *gime, const pixel_t *palette) inline gime_device::palette_resolver::palette_resolver(gime_device &gime, const pixel_t *palette)
: m_gime(gime)
, m_palette(palette)
{ {
m_gime = gime;
m_palette = palette;
memset(m_resolved_palette, 0, sizeof(m_resolved_palette)); memset(m_resolved_palette, 0, sizeof(m_resolved_palette));
m_current_resolved_palette = -1; m_current_resolved_palette = -1;
} }
@ -1920,12 +1920,12 @@ inline gime_base_device::palette_resolver::palette_resolver(gime_base_device *gi
// palette_resolver::get_palette // palette_resolver::get_palette
//------------------------------------------------- //-------------------------------------------------
inline const gime_base_device::pixel_t *gime_base_device::palette_resolver::get_palette(uint16_t palette_rotation) inline const gime_device::pixel_t *gime_device::palette_resolver::get_palette(uint16_t palette_rotation)
{ {
if (UNEXPECTED(m_current_resolved_palette != palette_rotation)) if (UNEXPECTED(m_current_resolved_palette != palette_rotation))
{ {
for (int i = 0; i < 16; i++) for (int i = 0; i < 16; i++)
m_resolved_palette[i] = lookup(m_gime->m_palette_rotated[palette_rotation][i]); m_resolved_palette[i] = lookup(m_gime.m_palette_rotated[palette_rotation][i]);
m_current_resolved_palette = palette_rotation; m_current_resolved_palette = palette_rotation;
} }
return m_resolved_palette; return m_resolved_palette;
@ -1937,7 +1937,7 @@ inline const gime_base_device::pixel_t *gime_base_device::palette_resolver::get_
// palette_resolver::lookup // palette_resolver::lookup
//------------------------------------------------- //-------------------------------------------------
inline gime_base_device::pixel_t gime_base_device::palette_resolver::lookup(uint8_t color) inline gime_device::pixel_t gime_device::palette_resolver::lookup(uint8_t color)
{ {
assert(color <= 63); assert(color <= 63);
return m_palette[color]; return m_palette[color];
@ -1949,7 +1949,7 @@ inline gime_base_device::pixel_t gime_base_device::palette_resolver::lookup(uint
// hires_font // hires_font
//------------------------------------------------- //-------------------------------------------------
const uint8_t gime_base_device::hires_font[128][12] = const uint8_t gime_device::hires_font[128][12] =
{ {
{ 0x38, 0x44, 0x40, 0x40, 0x40, 0x44, 0x38, 0x10}, { 0x44, 0x00, 0x44, 0x44, 0x44, 0x4C, 0x34, 0x00}, { 0x38, 0x44, 0x40, 0x40, 0x40, 0x44, 0x38, 0x10}, { 0x44, 0x00, 0x44, 0x44, 0x44, 0x4C, 0x34, 0x00},
{ 0x08, 0x10, 0x38, 0x44, 0x7C, 0x40, 0x38, 0x00}, { 0x10, 0x28, 0x38, 0x04, 0x3C, 0x44, 0x3C, 0x00}, { 0x08, 0x10, 0x38, 0x44, 0x7C, 0x40, 0x38, 0x00}, { 0x10, 0x28, 0x38, 0x04, 0x3C, 0x44, 0x3C, 0x00},
@ -2023,27 +2023,26 @@ const uint8_t gime_base_device::hires_font[128][12] =
// VARIATIONS // VARIATIONS
//************************************************************************** //**************************************************************************
namespace
{
class gime_ntsc_device : public gime_device
{
public:
gime_ntsc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: gime_device(mconfig, GIME_NTSC, tag, owner, clock, ntsc_round_fontdata8x12)
{
}
};
class gime_pal_device : public gime_device
{
public:
gime_pal_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: gime_device(mconfig, GIME_PAL, tag, owner, clock, pal_round_fontdata8x12)
{
}
};
};
DEFINE_DEVICE_TYPE(GIME_NTSC, gime_ntsc_device, "gime_ntsc", "CoCo GIME (NTSC)") DEFINE_DEVICE_TYPE(GIME_NTSC, gime_ntsc_device, "gime_ntsc", "CoCo GIME (NTSC)")
DEFINE_DEVICE_TYPE(GIME_PAL, gime_pal_device, "gime_pal", "CoCo GIME (PAL)") DEFINE_DEVICE_TYPE(GIME_PAL, gime_pal_device, "gime_pal", "CoCo GIME (PAL)")
//-------------------------------------------------
// gime_ntsc_device
//-------------------------------------------------
gime_ntsc_device::gime_ntsc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: gime_base_device(mconfig, GIME_NTSC, tag, owner, clock, ntsc_round_fontdata8x12)
{
}
//-------------------------------------------------
// gime_pal_device
//-------------------------------------------------
gime_pal_device::gime_pal_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: gime_base_device(mconfig, GIME_PAL, tag, owner, clock, pal_round_fontdata8x12)
{
}

52
src/mame/video/gime.h
View File

@ -28,22 +28,22 @@
#define MCFG_GIME_FSYNC_CALLBACK MCFG_MC6847_FSYNC_CALLBACK #define MCFG_GIME_FSYNC_CALLBACK MCFG_MC6847_FSYNC_CALLBACK
#define MCFG_GIME_IRQ_CALLBACK(_write) \ #define MCFG_GIME_IRQ_CALLBACK(_write) \
devcb = &gime_base_device::set_irq_wr_callback(*device, DEVCB_##_write); devcb = &gime_device::set_irq_wr_callback(*device, DEVCB_##_write);
#define MCFG_GIME_FIRQ_CALLBACK(_write) \ #define MCFG_GIME_FIRQ_CALLBACK(_write) \
devcb = &gime_base_device::set_firq_wr_callback(*device, DEVCB_##_write); devcb = &gime_device::set_firq_wr_callback(*device, DEVCB_##_write);
#define MCFG_GIME_FLOATING_BUS_CALLBACK(_read) \ #define MCFG_GIME_FLOATING_BUS_CALLBACK(_read) \
devcb = &gime_base_device::set_floating_bus_rd_callback(*device, DEVCB_##_read); devcb = &gime_device::set_floating_bus_rd_callback(*device, DEVCB_##_read);
#define MCFG_GIME_MAINCPU(_tag) \ #define MCFG_GIME_MAINCPU(_tag) \
gime_base_device::set_maincpu_tag(*device, _tag); gime_device::set_maincpu_tag(*device, _tag);
#define MCFG_GIME_RAM(_tag) \ #define MCFG_GIME_RAM(_tag) \
gime_base_device::set_ram_tag(*device, _tag); gime_device::set_ram_tag(*device, _tag);
#define MCFG_GIME_EXT(_tag) \ #define MCFG_GIME_EXT(_tag) \
gime_base_device::set_ext_tag(*device, _tag); gime_device::set_ext_tag(*device, _tag);
//************************************************************************** //**************************************************************************
@ -52,15 +52,15 @@
class cococart_slot_device; class cococart_slot_device;
class gime_base_device : public mc6847_friend_device, public sam6883_friend_device class gime_device : public mc6847_friend_device, public sam6883_friend_device
{ {
public: public:
template <class Object> static devcb_base &set_irq_wr_callback(device_t &device, Object &&cb) { return downcast<gime_base_device &>(device).m_write_irq.set_callback(std::forward<Object>(cb)); } template <class Object> static devcb_base &set_irq_wr_callback(device_t &device, Object &&cb) { return downcast<gime_device &>(device).m_write_irq.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_firq_wr_callback(device_t &device, Object &&cb) { return downcast<gime_base_device &>(device).m_write_firq.set_callback(std::forward<Object>(cb)); } template <class Object> static devcb_base &set_firq_wr_callback(device_t &device, Object &&cb) { return downcast<gime_device &>(device).m_write_firq.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_floating_bus_rd_callback(device_t &device, Object &&cb) { return downcast<gime_base_device &>(device).m_read_floating_bus.set_callback(std::forward<Object>(cb)); } template <class Object> static devcb_base &set_floating_bus_rd_callback(device_t &device, Object &&cb) { return downcast<gime_device &>(device).m_read_floating_bus.set_callback(std::forward<Object>(cb)); }
static void set_maincpu_tag(device_t &device, const char *tag) { downcast<gime_base_device &>(device).m_maincpu_tag = tag; } static void set_maincpu_tag(device_t &device, const char *tag) { downcast<gime_device &>(device).m_maincpu_tag = tag; }
static void set_ram_tag(device_t &device, const char *tag) { downcast<gime_base_device &>(device).m_ram_tag = tag; } static void set_ram_tag(device_t &device, const char *tag) { downcast<gime_device &>(device).m_ram_tag = tag; }
static void set_ext_tag(device_t &device, const char *tag) { downcast<gime_base_device &>(device).m_ext_tag = tag; } static void set_ext_tag(device_t &device, const char *tag) { downcast<gime_device &>(device).m_ext_tag = tag; }
// read/write // read/write
DECLARE_READ8_MEMBER( read ) { return read(offset); } DECLARE_READ8_MEMBER( read ) { return read(offset); }
@ -91,7 +91,7 @@ public:
void set_il2(bool value) { set_interrupt_value(INTERRUPT_EI2, value); } void set_il2(bool value) { set_interrupt_value(INTERRUPT_EI2, value); }
protected: protected:
gime_base_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, const uint8_t *fontdata); gime_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, const uint8_t *fontdata);
// device-level overrides // device-level overrides
virtual void device_start(void) override; virtual void device_start(void) override;
@ -124,17 +124,17 @@ private:
uint16_t m_palette[160]; uint16_t m_palette[160];
}; };
typedef uint32_t (gime_base_device::*get_data_func)(uint32_t, uint8_t *, uint8_t *); typedef uint32_t (gime_device::*get_data_func)(uint32_t, uint8_t *, uint8_t *);
class palette_resolver class palette_resolver
{ {
public: public:
palette_resolver(gime_base_device *gime, const pixel_t *palette); palette_resolver(gime_device &gime, const pixel_t *palette);
const pixel_t *get_palette(uint16_t palette_rotation); const pixel_t *get_palette(uint16_t palette_rotation);
pixel_t lookup(uint8_t color); pixel_t lookup(uint8_t color);
private: private:
gime_base_device *m_gime; gime_device &m_gime;
const pixel_t *m_palette; const pixel_t *m_palette;
pixel_t m_resolved_palette[16]; pixel_t m_resolved_palette[16];
int m_current_resolved_palette; int m_current_resolved_palette;
@ -279,7 +279,7 @@ private:
uint32_t record_scanline_res(int scanline); uint32_t record_scanline_res(int scanline);
// rendering sampled graphics // rendering sampled graphics
typedef uint32_t (gime_base_device::*emit_samples_proc)(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette); typedef uint32_t (gime_device::*emit_samples_proc)(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette);
uint32_t emit_dummy_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette); uint32_t emit_dummy_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette);
uint32_t emit_mc6847_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette); uint32_t emit_mc6847_samples(const scanline_record *scanline, int sample_start, int sample_count, pixel_t *pixels, const pixel_t *palette);
template<int xscale> template<int xscale>
@ -295,19 +295,7 @@ private:
// VARIATIONS // VARIATIONS
//************************************************************************** //**************************************************************************
class gime_ntsc_device : public gime_base_device extern const device_type GIME_NTSC;
{ extern const device_type GIME_PAL;
public:
gime_ntsc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
};
class gime_pal_device : public gime_base_device
{
public:
gime_pal_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
};
DECLARE_DEVICE_TYPE(GIME_NTSC, gime_ntsc_device)
DECLARE_DEVICE_TYPE(GIME_PAL, gime_pal_device)
#endif //MAME_VIDEO_GIME_H #endif //MAME_VIDEO_GIME_H