void cinemat_vh_screenrefresh (struct osd_bitmap *bitmap, int full_refresh)
{
if (backdrop && overlay)
vector_vh_update_artwork(bitmap, overlay, backdrop, full_refresh);
else if (overlay)
vector_vh_update_overlay(bitmap, overlay, full_refresh);
else if (backdrop)
vector_vh_update_backdrop(bitmap, backdrop, full_refresh);
else
vector_vh_update(bitmap, full_refresh);
vector_clear_list ();
}
void sega_generate_vector_list (void)
{
int deltax, deltay;
int currentX, currentY;
int vectorIndex;
int symbolIndex;
int rotate, scale;
int attrib;
int angle, length;
int color;
int draw;
vector_clear_list();
symbolIndex = 0; /* Reset vector PC to 0 */
/*
* walk the symbol list until 'last symbol' set
*/
do {
draw = vectorram[symbolIndex++];
if (draw & 1) /* if symbol active */
{
currentX = vectorram[symbolIndex + 0] | (vectorram[symbolIndex + 1] << 8);
currentY = vectorram[symbolIndex + 2] | (vectorram[symbolIndex + 3] << 8);
vectorIndex = vectorram[symbolIndex + 4] | (vectorram[symbolIndex + 5] << 8);
rotate = vectorram[symbolIndex + 6] | (vectorram[symbolIndex + 7] << 8);
scale = vectorram[symbolIndex + 8];
currentX = ((currentX & 0x7ff) - min_x) << VEC_SHIFT;
currentY = (max_y - (currentY & 0x7ff)) << VEC_SHIFT;
vector_add_point ( currentX, currentY, 0, 0);
vectorIndex &= 0xfff;
/* walk the vector list until 'last vector' bit */
/* is set in attributes */
do
{
attrib = vectorram[vectorIndex + 0];
length = vectorram[vectorIndex + 1];
angle = vectorram[vectorIndex + 2] | (vectorram[vectorIndex + 3] << 8);
vectorIndex += 4;
/* calculate deltas based on len, angle(s), and scale factor */
angle = (angle + rotate) & 0x3ff;
deltax = sinTable[angle] * scale * length;
deltay = cosTable[angle] * scale * length;
currentX += deltax >> 7;
currentY -= deltay >> 7;
color = attrib & 0x7e;
if ((attrib & 1) && color)
{
if (translucency)
intensity = 0xa0; /* leave room for translucency */
else
intensity = 0xff;
}
else
intensity = 0;
vector_add_point ( currentX, currentY, color, intensity );
} while (!(attrib & 0x80));
}
symbolIndex += 9;
if (symbolIndex >= vectorram_size)
break;
} while (!(draw & 0x80));
static void cchasm_refresh (void)
{
int pc = 0;
int done = 0;
int opcode, data;
int currentx = 0, currenty = 0;
int scalex = 0, scaley = 0;
int color = 0;
int total_length = 1; /* length of all lines drawn in a frame */
int move = 0;
vector_clear_list();
while (!done)
{
data = cchasm_ram[pc];
opcode = data >> 12;
data &= 0xfff;
if ((opcode > COLOR) && (data & 0x800))
data |= 0xfffff000;
pc++;
switch (opcode)
{
case HALT:
done=1;
break;
case JUMP:
pc = data - 0xb00;
logerror("JUMP to %x\n", data);
break;
case COLOR:
color = VECTOR_COLOR444(data ^ 0xfff);
break;
case SCALEY:
scaley = data << 5;
break;
case POSY:
move = 1;
currenty = ycenter + (data << 16);
break;
case SCALEX:
scalex = data << 5;
break;
case POSX:
move = 1;
currentx = xcenter - (data << 16);
break;
case LENGTH:
if (move)
{
vector_add_point (currentx, currenty, 0, 0);
move = 0;
}
currentx -= data * scalex;
currenty += data * scaley;
total_length += abs(data);
if (color)
vector_add_point (currentx, currenty, color, 0xff);
else
move = 1;
break;
default:
logerror("Unknown refresh proc opcode %x with data %x at pc = %x\n", opcode, data, pc-2);
done = 1;
break;
}
}
/* Refresh processor runs with 6 MHz */
timer_set (attotime_mul(ATTOTIME_IN_HZ(6000000), total_length), NULL, 0, cchasm_refresh_end);
}
static void sega_generate_vector_list(running_machine &machine)
{
segag80v_state *state = machine.driver_data<segag80v_state>();
UINT8 *sintable = state->memregion("proms")->base();
double total_time = 1.0 / (double)IRQ_CLOCK;
UINT16 symaddr = 0;
UINT8 *vectorram = state->m_vectorram;
vector_clear_list();
/* Loop until we run out of time. */
while (total_time > 0)
{
UINT16 curx, cury, xaccum, yaccum;
UINT16 vecaddr, symangle;
UINT8 scale, draw;
/* The "draw" flag is clocked at the end of phase 0. */
draw = vectorram[symaddr++ & 0xfff];
/* The low byte of the X coordinate is latched into the */
/* up/down counters at U15/U16 during phase 1. */
curx = vectorram[symaddr++ & 0xfff];
/* The low 3 bits of the high byte of the X coordinate are */
/* latched into the up/down counter at U17 during phase 2. */
/* Bit 2 of the input is latched as both bit 2 and 3. */
curx |= (vectorram[symaddr++ & 0xfff] & 7) << 8;
curx |= (curx << 1) & 0x800;
/* The low byte of the Y coordinate is latched into the */
/* up/down counters at U18/U19 during phase 3. */
cury = vectorram[symaddr++ & 0xfff];
/* The low 3 bits of the high byte of the X coordinate are */
/* latched into the up/down counter at U17 during phase 4. */
/* Bit 2 of the input is latched as both bit 2 and 3. */
cury |= (vectorram[symaddr++ & 0xfff] & 7) << 8;
cury |= (cury << 1) & 0x800;
/* The low byte of the vector address is latched into the */
/* counters at U10/U11 during phase 5. */
vecaddr = vectorram[symaddr++ & 0xfff];
/* The low 4 bits of the high byte of the vector address is */
/* latched into the counter at U12 during phase 6. */
vecaddr |= (vectorram[symaddr++ & 0xfff] & 0xf) << 8;
/* The low byte of the symbol angle is latched into the tri- */
/* state flip flop at U55 at the end of phase 7. */
symangle = vectorram[symaddr++ & 0xfff];
/* The low 2 bits of the high byte of the symbol angle are */
/* latched into flip flops at U26 at the end of phase 8. */
symangle |= (vectorram[symaddr++ & 0xfff] & 3) << 8;
/* The scale is latched in phase 9 as the X input to the */
/* 25LS14 multiplier at U8. */
scale = vectorram[symaddr++ & 0xfff];
/* Account for the 10 phases so far. */
total_time -= 10.0 / (double)U51_CLOCK;
/* Skip the rest if we're not drawing this symbol. */
if (draw & 1)
{
int adjx, adjy, clipped;
/* Add a starting point to the vector list. */
clipped = adjust_xy(state, curx, cury, &adjx, &adjy);
if (!clipped)
vector_add_point(machine, adjx, adjy, 0, 0);
/* Loop until we run out of time. */
while (total_time > 0)
{
UINT16 vecangle, length, deltax, deltay;
UINT8 attrib, intensity;
UINT32 color;
/* The 'attribute' byte is latched at the end of phase 10 into */
/* the tri-state flip flop at U2. The low bit controls whether */
/* or not the beam is enabled. Bits 1-6 control the RGB color */
/* (2 bits per component). In addition, bit 7 of this value is */
/* latched into U52, which controls the pre-load value for the */
/* phase generator. If bit 7 is high, then the phase generator */
/* will reset back to 0 and draw a new symbol; if bit 7 is low */
/* the phase generator will reset back to 10 and draw another */
/* vector. */
attrib = vectorram[vecaddr++ & 0xfff];
/* The length of the vector is loaded into the shift registers */
/* at U6/U7 during phase 11. During phase 12, the 25LS14 */
/* multiplier at U8 is used to multiply the length by the */
/* scale that was loaded during phase 9. The length is clocked */
/* bit by bit out of U6/U7 and the result is clocked into the */
/* other side. After the multiply, the 9 MSBs are loaded into */
/* the counter chain at U15/16/17 and are used to count how */
/* long to draw the vector. */
length = (vectorram[vecaddr++ & 0xfff] * scale) >> 7;
/* The vector angle low byte is latched at the end of phase 12 */
/* into the tri-state flip flop at U56. */
vecangle = vectorram[vecaddr++ & 0xfff];
/* The vector angle high byte is preset on the CD bus during */
/* phases 13 and 14, and is used as inputs to the adder at */
/* U46. */
vecangle |= (vectorram[vecaddr++ & 0xfff] & 3) << 8;
/* The X increment value is looked up first (phase 13). The */
/* sum of the latched symbol angle and the vector angle is */
/* used as input to the PROM at U39. A0 is tied to ground. */
/* A1-A9 map to bits 0-8 of the summed angles. The output from */
/* the PROM is latched into U48. */
deltax = sintable[((vecangle + symangle) & 0x1ff) << 1];
/* The Y increment value is looked up second (phase 14). The */
/* angle sum is used once again as the input to the PROM, but */
/* this time an additional 0x100 is effectively added to it */
/* before it is used; this separates sin from cos. The output */
/* from the PROM is latched into U49. */
deltay = sintable[((vecangle + symangle + 0x100) & 0x1ff) << 1];
/* Account for the 4 phases for data fetching. */
total_time -= 4.0 / (double)U51_CLOCK;
/* Compute color/intensity values from the attributes */
color = VECTOR_COLOR222((attrib >> 1) & 0x3f);
if ((attrib & 1) && color)
intensity = 0xff;
else
intensity = 0;
/* Loop over the length of the vector. */
clipped = adjust_xy(state, curx, cury, &adjx, &adjy);
xaccum = yaccum = 0;
while (length-- != 0 && total_time > 0)
{
int newclip;
/* The adders at U44/U45 are used as X accumulators. The value */
/* from U48 is repeatedly added to itself here. The carry out */
/* of bit 8 clocks the up/down counters at U15/U16/U17. Bit 7 */
/* of the input value from U48 is used as a carry in to round */
/* small values downward and larger values upward. */
xaccum += deltax + (deltax >> 7);
/* Bit 9 of the summed angles controls the direction the up/ */
/* down counters at U15/U16/U17. */
if (((vecangle + symangle) & 0x200) == 0)
curx += xaccum >> 8;
else
curx -= xaccum >> 8;
xaccum &= 0xff;
/* The adders at U46/U47 are used as Y accumulators. The value */
/* from U49 is repeatedly added to itself here. The carry out */
/* of bit 8 clocks the up/down counters at U18/U19/U20. Bit 7 */
/* of the input value from U49 is used as a carry in to round */
/* small values downward and larger values upward. */
yaccum += deltay + (deltay >> 7);
/* Bit 9 of the summed angles controls the direction the up/ */
/* down counters at U18/U19/U20. */
if (((vecangle + symangle + 0x100) & 0x200) == 0)
cury += yaccum >> 8;
else
cury -= yaccum >> 8;
yaccum &= 0xff;
/* Apply the clipping from the DAC circuit. If the values clip */
/* the beam is turned off, but the computations continue right */
/* on going. */
newclip = adjust_xy(state, curx, cury, &adjx, &adjy);
if (newclip != clipped)
{
/* if we're just becoming unclipped, add an empty point */
if (!newclip)
vector_add_point(machine, adjx, adjy, 0, 0);
/* otherwise, add a colored point */
else
vector_add_point(machine, adjx, adjy, color, intensity);
}
clipped = newclip;
/* account for vector drawing time */
total_time -= 1.0 / (double)VCL_CLOCK;
}
/* We're done; if we are not clipped, add a final point. */
if (!clipped)
vector_add_point(machine, adjx, adjy, color, intensity);
/* if the high bit of the attribute is set, we break out of */
/* this loop and fetch another symbol */
if (attrib & 0x80)
break;
}
static void cchasm_refresh (running_machine &machine)
{
cchasm_state *state = machine.driver_data<cchasm_state>();
int pc = 0;
int done = 0;
int opcode, data;
int currentx = 0, currenty = 0;
int scalex = 0, scaley = 0;
int color = 0;
int total_length = 1; /* length of all lines drawn in a frame */
int move = 0;
vector_clear_list();
while (!done)
{
data = state->m_ram[pc];
opcode = data >> 12;
data &= 0xfff;
if ((opcode > COLOR) && (data & 0x800))
data |= 0xfffff000;
pc++;
switch (opcode)
{
case HALT:
done=1;
break;
case JUMP:
pc = data - 0xb00;
logerror("JUMP to %x\n", data);
break;
case COLOR:
color = VECTOR_COLOR444(data ^ 0xfff);
break;
case SCALEY:
scaley = data << 5;
break;
case POSY:
move = 1;
currenty = state->m_ycenter + (data << 16);
break;
case SCALEX:
scalex = data << 5;
break;
case POSX:
move = 1;
currentx = state->m_xcenter - (data << 16);
break;
case LENGTH:
if (move)
{
vector_add_point (machine, currentx, currenty, 0, 0);
move = 0;
}
currentx -= data * scalex;
currenty += data * scaley;
total_length += abs(data);
if (color)
vector_add_point (machine, currentx, currenty, color, 0xff);
else
move = 1;
break;
default:
logerror("Unknown refresh proc opcode %x with data %x at pc = %x\n", opcode, data, pc-2);
done = 1;
break;
}
}
/* Refresh processor runs with 6 MHz */
machine.scheduler().timer_set (attotime::from_hz(6000000) * total_length, FUNC(cchasm_refresh_end));
}
int cinemat_clear_list(void)
{
if (osd_skip_this_frame())
vector_clear_list ();
return ignore_interrupt();
}
void spacewar_vh_screenrefresh (struct osd_bitmap *bitmap, int full_refresh)
{
int tk[] = {3, 8, 4, 9, 1, 6, 2, 7, 5, 0};
int i, pwidth, pheight, key, row, col, sw_option;
float scale;
struct osd_bitmap vector_bitmap;
struct rectangle rect;
static int sw_option_change;
if (spacewar_panel == NULL)
{
vector_vh_update(bitmap, full_refresh);
vector_clear_list ();
return;
}
pwidth = spacewar_panel->artwork->width;
pheight = spacewar_panel->artwork->height;
vector_bitmap.width = bitmap->width;
vector_bitmap.height = bitmap->height - pheight;
vector_bitmap._private = bitmap->_private;
vector_bitmap.line = bitmap->line;
vector_vh_update(&vector_bitmap,full_refresh);
vector_clear_list ();
if (full_refresh)
copybitmap(bitmap,spacewar_panel->artwork,0,0,
0,bitmap->height - pheight, 0,TRANSPARENCY_NONE,0);
scale = pwidth/1024.0;
sw_option = input_port_2_r(0) | ((input_port_1_r(0) << 6) & 0x300);
sw_option_change ^= sw_option;
for (i = 0; i < 10; i++)
{
if (sw_option_change & (1 << i) || full_refresh)
{
key = tk[i];
col = key % 5;
row = key / 5;
rect.min_x = scale * (465 + 20 * col);
rect.max_x = scale * (465 + 20 * col + 18);
rect.min_y = scale * (39 + 20 * row) + vector_bitmap.height;
rect.max_y = scale * (39 + 20 * row + 18) + vector_bitmap.height;
if (sw_option & (1 << i))
{
copybitmap(bitmap,spacewar_panel->artwork,0,0,
0, vector_bitmap.height, &rect,TRANSPARENCY_NONE,0);
}
else
{
copybitmap(bitmap,spacewar_pressed_panel->artwork,0,0,
0, vector_bitmap.height, &rect,TRANSPARENCY_NONE,0);
}
osd_mark_dirty (rect.min_x, rect.min_y,
rect.max_x, rect.max_y, 0);
}
}
sw_option_change = sw_option;
}