INLINE double get_verint_scanline_time(void)
{
int scanline = tms34061.regs[TMS34061_VERINT] - tms34061.regs[TMS34061_VERENDBLNK];
double result;
if (scanline < 0)
scanline += tms34061.regs[TMS34061_VERTOTAL];
/* we fire at the HBLANK signal */
result = cpu_getscanlinetime(scanline) + cpu_getscanlineperiod() * 0.9;
if (result < cpu_getscanlineperiod() * 10)
result += TIME_IN_HZ(Machine->screen[0].refresh);
return result;
}
void atarisys2_video_update (int param)
{
atarisys2_update_display_list (param);
param += 8;
if (param < 384)
timer_set (8.0 * cpu_getscanlineperiod (), param, atarisys2_video_update);
}
void vindictr_update (int param)
{
int yscroll;
/* update the display list */
yscroll = vindictr_update_display_list (param);
/* reset the timer */
if (!param)
{
int next = 8 - (yscroll & 7);
timer_set (cpu_getscanlineperiod () * (double)next, next, vindictr_update);
}
else if (param < 240)
timer_set (cpu_getscanlineperiod () * 8.0, param + 8, vindictr_update);
}
static void mcr68_493_callback(int param)
{
v493_irq_state = 1;
update_mcr68_interrupts();
timer_set(cpu_getscanlineperiod(), 0, mcr68_493_off_callback);
logerror("--- (INT1) ---\n");
}
static void alpha_row_update(int scanline)
{
data16_t *check = &atarigen_alpha[(scanline / 8) * 64 + 42];
/* check for interrupts in the alpha ram */
/* the interrupt occurs on the HBLANK of the 6th scanline following */
if (check < &atarigen_alpha[0x7c0] && (*check & 0x8000))
timer_set(cpu_getscanlineperiod() * 6.9, 0, irq_gen);
/* update the playfield and motion objects */
skullxbo_scanline_update(scanline);
}
void atarisys2_32v_interrupt (int param)
{
/* generate the 32V interrupt (IRQ 2) */
if (!irq_hold2 && (READ_WORD (&atarisys2_interrupt_enable[0]) & 4))
{
cpu_cause_interrupt (0, 2);
irq_hold2 = 1;
}
/* set the timer for the next one */
param += 64;
if (param < 384)
timer_set (64.0 * cpu_getscanlineperiod (), param, atarisys2_32v_interrupt);
}
static MACHINE_INIT( beathead )
{
/* reset the common subsystems */
atarigen_eeprom_reset();
atarigen_interrupt_reset(update_interrupts);
atarijsa_reset();
/* the code is temporarily mapped at 0 at startup */
/* just copying the first 0x40 bytes is sufficient */
memcpy(ram_base, rom_base, 0x40);
/* compute the timing of the HBLANK interrupt and set the first timer */
hblank_offset = cpu_getscanlineperiod() * ((455. - 336. - 25.) / 455.);
timer_set(cpu_getscanlinetime(0) - hblank_offset, 0, scanline_callback);
/* reset IRQs */
irq_line_state = CLEAR_LINE;
irq_state[0] = irq_state[1] = irq_state[2] = 0;
irq_enable[0] = irq_enable[1] = irq_enable[2] = 0;
}
/* timer callback to handle reloading the H counter and generate IRQ4 */
void vdp_reload_counter(int scanline)
{
/* generate an int if they're enabled */
if (genesis_vdp_regs[0] & 0x10)/* && !(misc_io_data[7] & 0x10))*/
if (scanline != 0 || genesis_vdp_regs[10] == 0)
{
scanline_int = 1;
update_interrupts();
timer_set(cpu_getscanlinetime(scanline + 1), 0, vdp_int4_off);
}
/* advance to the next scanline */
/* behavior 2: 0 count means interrupt after one scanline */
/* (this behavior matches the Sega C2 emulator) */
scanline += genesis_vdp_regs[10] + 1;
if (scanline >= 224)
scanline = 0;
/* set a timer */
timer_adjust(scan_timer, cpu_getscanlinetime(scanline) + cpu_getscanlineperiod() * (320. / 342.), scanline, 0);
}
void draw_border(mame_bitmap *bitmap,
int full_refresh, /* Full refresh flag */
int TopBorderLines, /* Border lines before actual screen */
int ScreenLines, /* Screen height in pixels */
int BottomBorderLines, /* Border lines below screen */
int LeftBorderPixels, /* Border pixels to the left of each screen line */
int ScreenPixels, /* Width of actual screen in pixels */
int RightBorderPixels, /* Border pixels to the right of each screen line */
int LeftBorderCycles, /* Cycles taken to draw left border of each scan line */
int ScreenCycles, /* Cycles taken to draw screen data part of each scan line */
int RightBorderCycles, /* Cycles taken to draw right border of each scan line */
int HorizontalRetraceCycles, /* Cycles taken to return to LHS of CRT after each scan line */
int VRetraceTime, /* Cycles taken before start of first border line */
int EventID) /* Event ID of border messages */
{
EVENT_LIST_ITEM *pItem;
int TotalScreenHeight = TopBorderLines+ScreenLines+BottomBorderLines;
int TotalScreenWidth = LeftBorderPixels+ScreenPixels+RightBorderPixels;
int DisplayCyclesPerLine = LeftBorderCycles+ScreenCycles+RightBorderCycles;
int CyclesPerLine = DisplayCyclesPerLine+HorizontalRetraceCycles;
int CyclesSoFar = 0;
int NumItems, CurrItem = 0, NextItem;
int Count, ScrX, NextScrX, ScrY;
rectangle r;
pItem = EventList_GetFirstItem();
NumItems = EventList_NumEvents();
if (NumItems)
{
int CyclesPerFrame = (int)(Machine->drv->cpu[0].cpu_clock / Machine->drv->frames_per_second);
logerror ("Event count = %d, curr cycle = %ld, total cycles = %ld \n", (int) NumItems, (long) TIME_TO_CYCLES(0,cpu_getscanline()*cpu_getscanlineperiod()), (long) CyclesPerFrame);
}
for (Count = 0; Count < NumItems; Count++)
{
logerror ("Event no %05d, ID = %04x, data = %04x, time = %ld\n", Count, pItem[Count].Event_ID, pItem[Count].Event_Data, (long) pItem[Count].Event_Time);
}
/* Find the first and second events with the correct ID */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID))
CurrItem++;
NextItem = CurrItem + 1;
while ((NextItem < NumItems) && (pItem[NextItem].Event_ID != EventID))
NextItem++;
/* Single border colour */
if ((CurrItem < NumItems) && (NextItem >= NumItems))
CurrBorderColor = pItem[CurrItem].Event_Data;
if ((NextItem >= NumItems) && (CurrBorderColor==LastDisplayedBorderColor) && !full_refresh)
{
/* Do nothing if border colour has not changed */
}
else if (NextItem >= NumItems)
{
/* Single border colour - this is not strictly correct as the
colour change may have occurred midway through the frame
or after the last visible border line however the whole
border would be redrawn in the correct colour during the
next frame anyway! */
r.min_x = 0;
r.max_x = TotalScreenWidth-1;
r.min_y = 0;
r.max_y = TopBorderLines-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = 0;
r.max_x = LeftBorderPixels-1;
r.min_y = TopBorderLines;
r.max_y = TopBorderLines+ScreenLines-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = LeftBorderPixels+ScreenPixels;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = 0;
r.max_x = TotalScreenWidth-1;
r.min_y = TopBorderLines+ScreenLines;
r.max_y = TotalScreenHeight-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
logerror ("Setting border colour to %d (Last = %d, Full Refresh = %d)\n", CurrBorderColor, LastDisplayedBorderColor, full_refresh);
LastDisplayedBorderColor = CurrBorderColor;
}
else
{
/* Multiple border colours */
/* Process entries before first displayed line */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= VRetraceTime))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
/* Draw top border */
CyclesSoFar = VRetraceTime;
for (ScrY = 0; ScrY < TopBorderLines; ScrY++)
{
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour on line */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours on a line */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Draw left and right borders next to screen lines */
for (ScrY = TopBorderLines; ScrY < (TopBorderLines+ScreenLines); ScrY++)
{
/* Draw left hand border */
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+LeftBorderCycles)))
{
/* Single colour */
r.max_x = LeftBorderPixels-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)LeftBorderPixels / (float)LeftBorderCycles;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+LeftBorderCycles)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)LeftBorderPixels / (float)LeftBorderCycles;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = LeftBorderPixels-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during screen draw */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= (CyclesSoFar+LeftBorderCycles+ScreenCycles)))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
/* Draw right hand border */
r.min_x = LeftBorderPixels+ScreenPixels;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours */
ScrX = LeftBorderPixels + ScreenPixels + (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)RightBorderPixels / (float)RightBorderCycles;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = LeftBorderPixels + ScreenPixels + (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)RightBorderPixels / (float)RightBorderCycles;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Draw bottom border */
for (ScrY = TopBorderLines+ScreenLines; ScrY < TotalScreenHeight; ScrY++)
{
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour on line */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours on a line */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Process colour changes after last displayed line */
while (CurrItem < NumItems)
{
if (pItem[CurrItem].Event_ID == EventID)
CurrBorderColor = pItem[CurrItem].Event_Data;
CurrItem++;
}
/* Set value to ensure redraw on next frame */
LastDisplayedBorderColor = -1;
logerror ("Multi coloured border drawn (last colour = %d)\n", CurrBorderColor);
}
/* Assume all other routines have processed their data from the list */
EventList_Reset();
EventList_SetOffsetStartTime ( TIME_TO_CYCLES(0,cpu_getscanline()*cpu_getscanlineperiod()) );
}
