1
/***************************************************************************
5
****************************************************************************
7
The basic video system involves a 4-bit-per-pixel bitmap, oriented
8
in inverted X/Y order. That is, pixels (0,0) and (1,0) come from the
9
byte at offset 0. Pixels (2,0) and (3,0) come from the byte at offset
10
256. Pixels (4,0) and (5,0) come from the byte at offset 512. Etc.
12
Defender and Stargate simply draw graphics to the framebuffer directly
13
with no extra intervention.
15
Later games added a pair of "special chips" (SC-01) to the board which
16
are special purpose blitters. During their operation they HALT the
17
main CPU so that they can control the busses. The operation of the
18
chips is described in detail below.
20
The original SC-01 had a bug that forced an XOR of the width and height
21
values with 4. This was fixed in the SC-02, which was used on several
24
Beginning with Sinistar, additional video tweaks were added.
26
In Sinistar, a clipping window can be specified and enabled in order
27
to prevent the blitter chip from drawing beyond a certain address.
28
This clipping window can be switched on and off at will.
30
In Blaster, a number of features were added. First, a fixed window can
31
be enabled which cuts off blitter drawing at 0x9700. Second, on a
32
per-scanline basis, an "erase behind" feature can be turned on which
33
clears the video RAM to 0 after it is refreshed to the screen. Third,
34
on a per-scanline basis, an alternate color can be latched as the new
37
For Mystic Marathon and the 3 other "2nd generation" Williams games,
38
a tilemap background layer was added. This layer consisted of 24x16
39
tiles and only scrolled in the X direction. In addition, the palette
40
was expanded to 1024 entries, some of which were used for the tilemap.
41
The traditional foreground bitmap could be configured to use any bank
42
of 16 colors from the full palette.
44
****************************************************************************
46
Blitter description from Sean Riddle's page:
48
This page contains information about the Williams Special Chips, which
49
were 'bit blitters'- block transfer chips that could move data around on
50
the screen and in memory faster than the CPU. In fact, I've timed the
51
special chips at 16 megs in 18.1 seconds. That's 910K/sec, not bad for
54
The blitters were not used in Defender and Stargate, but
55
were added to the ROM boards of the later games. Splat!, Blaster, Mystic
56
Marathon and Joust 2 used Special Chip 2s. The only difference that I've
57
seen is that SC1s have a small bug. When you tell the SC1 the size of
58
the data to move, you have to exclusive-or the width and height with 2.
59
The SC2s eliminate this bug.
61
The blitters were accessed at memory location $CA00-CA06.
63
CA01 is the mask, usually $FF to move all bits.
64
CA02-3 is the source data location.
65
CA04-5 is the destination data location.
67
Writing to CA00 starts the blit, and the byte written determines how the
70
Bit 0 indicates that the source data is either laid out linear, one
71
pixel after the last, or in screen format, where there are 256 bytes from
72
one pair of pixels to the next.
74
Bit 1 indicates the same, but for the destination data.
76
I'm not sure what bit 2 does. Looking at the image, I can't tell, but
77
perhaps it has to do with the mask. My test files only used a mask of $FF.
79
Bit 3 tells the blitter only to blit the foreground- that is, everything
80
that is not color 0. Also known as transparency mode.
82
Bit 4 is 'solid' mode. Only the color indicated by the mask is blitted.
83
Note that this just creates a rectangle unless bit 3 is also set, in which
84
case it blits the image, but in a solid color.
86
Bit 5 shifts the image one pixel to the right. Any data on the far right
87
jumps to the far left.
89
Bits 6 and 7 only blit every other pixel of the image. Bit 6 says even only,
90
while bit 7 says odd only.
92
***************************************************************************/
95
#include "video/resnet.h"
96
#include "includes/williams.h"
100
/*************************************
104
*************************************/
106
static void blitter_init(running_machine &machine, int blitter_config, const UINT8 *remap_prom);
107
static void create_palette_lookup(running_machine &machine);
108
static TILE_GET_INFO( get_tile_info );
109
static int blitter_core(address_space *space, int sstart, int dstart, int w, int h, int data);
113
/*************************************
115
* Williams video startup
117
*************************************/
119
static void state_save_register(running_machine &machine)
121
williams_state *state = machine.driver_data<williams_state>();
122
state_save_register_global(machine, state->m_blitter_window_enable);
123
state_save_register_global(machine, state->m_cocktail);
124
state_save_register_global_array(machine, state->m_blitterram);
125
state_save_register_global(machine, state->m_blitter_remap_index);
126
state_save_register_global(machine, state->m_blaster_color0);
127
state_save_register_global(machine, state->m_blaster_video_control);
128
state_save_register_global(machine, state->m_tilemap_xscroll);
129
state_save_register_global(machine, state->m_williams2_fg_color);
133
VIDEO_START( williams )
135
williams_state *state = machine.driver_data<williams_state>();
136
blitter_init(machine, state->m_blitter_config, NULL);
137
create_palette_lookup(machine);
138
state_save_register(machine);
142
VIDEO_START( blaster )
144
williams_state *state = machine.driver_data<williams_state>();
145
blitter_init(machine, state->m_blitter_config, machine.region("proms")->base());
146
create_palette_lookup(machine);
147
state_save_register(machine);
151
VIDEO_START( williams2 )
153
williams_state *state = machine.driver_data<williams_state>();
154
blitter_init(machine, state->m_blitter_config, NULL);
156
/* allocate paletteram */
157
machine.generic.paletteram.u8 = auto_alloc_array(machine, UINT8, 0x400 * 2);
158
state_save_register_global_pointer(machine, machine.generic.paletteram.u8, 0x400 * 2);
160
/* create the tilemap */
161
state->m_bg_tilemap = tilemap_create(machine, get_tile_info, tilemap_scan_cols, 24,16, 128,16);
162
tilemap_set_scrolldx(state->m_bg_tilemap, 2, 0);
164
state_save_register(machine);
169
/*************************************
171
* Williams video update
173
*************************************/
175
SCREEN_UPDATE( williams )
177
williams_state *state = screen->machine().driver_data<williams_state>();
181
/* precompute the palette */
182
for (x = 0; x < 16; x++)
183
pens[x] = state->m_palette_lookup[screen->machine().generic.paletteram.u8[x]];
186
for (y = cliprect->min_y; y <= cliprect->max_y; y++)
188
UINT8 *source = &state->m_videoram[y];
189
UINT32 *dest = BITMAP_ADDR32(bitmap, y, 0);
191
/* loop over columns */
192
for (x = cliprect->min_x & ~1; x <= cliprect->max_x; x += 2)
194
int pix = source[(x/2) * 256];
195
dest[x+0] = pens[pix >> 4];
196
dest[x+1] = pens[pix & 0x0f];
203
SCREEN_UPDATE( blaster )
205
williams_state *state = screen->machine().driver_data<williams_state>();
209
/* precompute the palette */
210
for (x = 0; x < 16; x++)
211
pens[x] = state->m_palette_lookup[screen->machine().generic.paletteram.u8[x]];
213
/* if we're blitting from the top, start with a 0 for color 0 */
214
if (cliprect->min_y == screen->visible_area().min_y || !(state->m_blaster_video_control & 1))
215
state->m_blaster_color0 = pens[0];
218
for (y = cliprect->min_y; y <= cliprect->max_y; y++)
220
int erase_behind = state->m_blaster_video_control & state->m_blaster_scanline_control[y] & 2;
221
UINT8 *source = &state->m_videoram[y];
222
UINT32 *dest = BITMAP_ADDR32(bitmap, y, 0);
224
/* latch a new color0 pen? */
225
if (state->m_blaster_video_control & state->m_blaster_scanline_control[y] & 1)
226
state->m_blaster_color0 = state->m_palette_lookup[state->m_blaster_palette_0[y] ^ 0xff];
228
/* loop over columns */
229
for (x = cliprect->min_x & ~1; x <= cliprect->max_x; x += 2)
231
int pix = source[(x/2) * 256];
233
/* clear behind us if requested */
235
source[(x/2) * 256] = 0;
238
dest[x+0] = (pix & 0xf0) ? pens[pix >> 4] : state->m_blaster_color0;
239
dest[x+1] = (pix & 0x0f) ? pens[pix & 0x0f] : state->m_blaster_color0;
246
SCREEN_UPDATE( williams2 )
248
williams_state *state = screen->machine().driver_data<williams_state>();
252
/* draw the background */
253
tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
255
/* fetch the relevant pens */
256
for (x = 1; x < 16; x++)
257
pens[x] = palette_get_color(screen->machine(), state->m_williams2_fg_color * 16 + x);
260
for (y = cliprect->min_y; y <= cliprect->max_y; y++)
262
UINT8 *source = &state->m_videoram[y];
263
UINT32 *dest = BITMAP_ADDR32(bitmap, y, 0);
265
/* loop over columns */
266
for (x = cliprect->min_x & ~1; x <= cliprect->max_x; x += 2)
268
int pix = source[(x/2) * 256];
271
dest[x+0] = pens[pix >> 4];
273
dest[x+1] = pens[pix & 0x0f];
281
/*************************************
283
* Williams palette I/O
285
*************************************/
287
static void create_palette_lookup(running_machine &machine)
289
williams_state *state = machine.driver_data<williams_state>();
290
static const int resistances_rg[3] = { 1200, 560, 330 };
291
static const int resistances_b[2] = { 560, 330 };
292
double weights_r[3], weights_g[3], weights_b[2];
295
/* compute palette information */
296
/* note that there really are pullup/pulldown resistors, but this situation is complicated */
297
/* by the use of transistors, so we ignore that and just use the realtive resistor weights */
298
compute_resistor_weights(0, 255, -1.0,
299
3, resistances_rg, weights_r, 0, 0,
300
3, resistances_rg, weights_g, 0, 0,
301
2, resistances_b, weights_b, 0, 0);
303
/* build a palette lookup */
304
state->m_palette_lookup = auto_alloc_array(machine, rgb_t, 256);
305
for (i = 0; i < 256; i++)
307
int r = combine_3_weights(weights_r, BIT(i,0), BIT(i,1), BIT(i,2));
308
int g = combine_3_weights(weights_g, BIT(i,3), BIT(i,4), BIT(i,5));
309
int b = combine_2_weights(weights_b, BIT(i,6), BIT(i,7));
311
state->m_palette_lookup[i] = MAKE_RGB(r, g, b);
316
WRITE8_HANDLER( williams2_paletteram_w )
318
static const UINT8 ztable[16] =
320
0x0, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9,
321
0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11
323
UINT8 entry_lo, entry_hi, i, r, g, b;
325
/* set the new value */
326
space->machine().generic.paletteram.u8[offset] = data;
328
/* pull the associated low/high bytes */
329
entry_lo = space->machine().generic.paletteram.u8[offset & ~1];
330
entry_hi = space->machine().generic.paletteram.u8[offset | 1];
332
/* update the palette entry */
333
i = ztable[(entry_hi >> 4) & 15];
334
b = ((entry_hi >> 0) & 15) * i;
335
g = ((entry_lo >> 4) & 15) * i;
336
r = ((entry_lo >> 0) & 15) * i;
337
palette_set_color(space->machine(), offset / 2, MAKE_RGB(r, g, b));
341
WRITE8_HANDLER( williams2_fg_select_w )
343
williams_state *state = space->machine().driver_data<williams_state>();
344
state->m_williams2_fg_color = data & 0x3f;
349
/*************************************
351
* Video position readout
353
*************************************/
355
READ8_HANDLER( williams_video_counter_r )
357
return space->machine().primary_screen->vpos() & 0xfc;
361
READ8_HANDLER( williams2_video_counter_r )
363
return space->machine().primary_screen->vpos();
368
/*************************************
372
*************************************/
374
static TILE_GET_INFO( get_tile_info )
376
williams_state *state = machine.driver_data<williams_state>();
377
int mask = machine.gfx[0]->total_elements - 1;
378
int data = state->m_williams2_tileram[tile_index];
379
int y = (tile_index >> 1) & 7;
382
switch (state->m_williams2_tilemap_config)
384
case WILLIAMS_TILEMAP_MYSTICM:
386
/* IC79 is a 74LS85 comparator that controls the low bit */
387
int a = 1 | ((color & 1) << 2) | ((color & 1) << 3);
388
int b = ((y & 6) >> 1);
390
color = (a > b) || ((a == b) && !casc);
394
case WILLIAMS_TILEMAP_TSHOOT:
395
/* IC79 is a 74LS157 selector jumpered to be enabled */
399
case WILLIAMS_TILEMAP_JOUST2:
400
/* IC79 is a 74LS157 selector jumpered to be disabled */
405
SET_TILE_INFO(0, data & mask, color, (data & ~mask) ? TILE_FLIPX : 0);
409
WRITE8_HANDLER( williams2_bg_select_w )
411
williams_state *state = space->machine().driver_data<williams_state>();
412
/* based on the tilemap config, only certain bits are used */
413
/* the rest are determined by other factors */
414
switch (state->m_williams2_tilemap_config)
416
case WILLIAMS_TILEMAP_MYSTICM:
417
/* IC79 is a 74LS85 comparator that controls the low bit */
421
case WILLIAMS_TILEMAP_TSHOOT:
422
/* IC79 is a 74LS157 selector jumpered to be enabled */
426
case WILLIAMS_TILEMAP_JOUST2:
427
/* IC79 is a 74LS157 selector jumpered to be disabled */
431
tilemap_set_palette_offset(state->m_bg_tilemap, data * 16);
435
WRITE8_HANDLER( williams2_tileram_w )
437
williams_state *state = space->machine().driver_data<williams_state>();
438
state->m_williams2_tileram[offset] = data;
439
tilemap_mark_tile_dirty(state->m_bg_tilemap, offset);
443
WRITE8_HANDLER( williams2_xscroll_low_w )
445
williams_state *state = space->machine().driver_data<williams_state>();
446
state->m_tilemap_xscroll = (state->m_tilemap_xscroll & ~0x00f) | ((data & 0x80) >> 4) | (data & 0x07);
447
tilemap_set_scrollx(state->m_bg_tilemap, 0, (state->m_tilemap_xscroll & 7) + ((state->m_tilemap_xscroll >> 3) * 6));
451
WRITE8_HANDLER( williams2_xscroll_high_w )
453
williams_state *state = space->machine().driver_data<williams_state>();
454
state->m_tilemap_xscroll = (state->m_tilemap_xscroll & 0x00f) | (data << 4);
455
tilemap_set_scrollx(state->m_bg_tilemap, 0, (state->m_tilemap_xscroll & 7) + ((state->m_tilemap_xscroll >> 3) * 6));
460
/*************************************
462
* Blaster-specific enhancements
464
*************************************/
466
WRITE8_HANDLER( blaster_remap_select_w )
468
williams_state *state = space->machine().driver_data<williams_state>();
469
state->m_blitter_remap_index = data;
470
state->m_blitter_remap = state->m_blitter_remap_lookup + data * 256;
474
WRITE8_HANDLER( blaster_video_control_w )
476
williams_state *state = space->machine().driver_data<williams_state>();
477
state->m_blaster_video_control = data;
482
/*************************************
484
* Blitter setup and control
486
*************************************/
488
static void blitter_init(running_machine &machine, int blitter_config, const UINT8 *remap_prom)
490
williams_state *state = machine.driver_data<williams_state>();
491
static const UINT8 dummy_table[] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 };
494
/* by default, there is no clipping window - this will be touched only by games that have one */
495
state->m_blitter_window_enable = 0;
497
/* switch off the video config */
498
state->m_blitter_xor = (blitter_config == WILLIAMS_BLITTER_SC01) ? 4 : 0;
500
/* create the remap table; if no PROM, make an identity remap table */
501
state->m_blitter_remap_lookup = auto_alloc_array(machine, UINT8, 256 * 256);
502
state->m_blitter_remap_index = 0;
503
state->m_blitter_remap = state->m_blitter_remap_lookup;
504
for (i = 0; i < 256; i++)
506
const UINT8 *table = remap_prom ? (remap_prom + (i & 0x7f) * 16) : dummy_table;
507
for (j = 0; j < 256; j++)
508
state->m_blitter_remap_lookup[i * 256 + j] = (table[j >> 4] << 4) | table[j & 0x0f];
513
WRITE8_HANDLER( williams_blitter_w )
515
williams_state *state = space->machine().driver_data<williams_state>();
516
int sstart, dstart, w, h, accesses;
517
int estimated_clocks_at_4MHz;
520
state->m_blitterram[offset] = data;
522
/* only writes to location 0 trigger the blit */
526
/* compute the starting locations */
527
sstart = (state->m_blitterram[2] << 8) + state->m_blitterram[3];
528
dstart = (state->m_blitterram[4] << 8) + state->m_blitterram[5];
530
/* compute the width and height */
531
w = state->m_blitterram[6] ^ state->m_blitter_xor;
532
h = state->m_blitterram[7] ^ state->m_blitter_xor;
534
/* adjust the width and height */
537
if (w == 255) w = 256;
538
if (h == 255) h = 256;
540
/* do the actual blit */
541
accesses = blitter_core(space, sstart, dstart, w, h, data);
543
/* based on the number of memory accesses needed to do the blit, compute how long the blit will take */
544
/* this is just a guess */
545
estimated_clocks_at_4MHz = 20 + 2 * accesses;
546
device_adjust_icount(&space->device(), -((estimated_clocks_at_4MHz + 3) / 4));
549
logerror("%04X:Blit @ %3d : %02X%02X -> %02X%02X, %3dx%3d, mask=%02X, flags=%02X, icount=%d, win=%d\n",
550
cpu_get_pc(&space->device()), space->machine().primary_screen->vpos(),
551
state->m_blitterram[2], state->m_blitterram[3],
552
state->m_blitterram[4], state->m_blitterram[5],
553
state->m_blitterram[6], state->m_blitterram[7],
554
state->m_blitterram[1], state->m_blitterram[0],
555
((estimated_clocks_at_4MHz + 3) / 4), state->m_blitter_window_enable);
559
WRITE8_HANDLER( williams2_blit_window_enable_w )
561
williams_state *state = space->machine().driver_data<williams_state>();
562
state->m_blitter_window_enable = data & 0x01;
567
/*************************************
571
*************************************/
573
INLINE void blit_pixel(address_space *space, int offset, int srcdata, int data, int mask, int solid)
575
williams_state *state = space->machine().driver_data<williams_state>();
576
/* always read from video RAM regardless of the bank setting */
577
int pix = (offset < 0xc000) ? state->m_videoram[offset] : space->read_byte(offset);
579
/* handle transparency */
582
if (!(srcdata & 0xf0)) mask |= 0xf0;
583
if (!(srcdata & 0x0f)) mask |= 0x0f;
586
/* handle solid versus source data */
589
pix |= solid & ~mask;
591
pix |= srcdata & ~mask;
593
/* if the window is enabled, only blit to videoram below the clipping address */
594
/* note that we have to allow blits to non-video RAM (e.g. tileram) because those */
595
/* are not blocked by the window enable */
596
if (!state->m_blitter_window_enable || offset < state->m_blitter_clip_address || offset >= 0xc000)
597
space->write_byte(offset, pix);
601
static int blitter_core(address_space *space, int sstart, int dstart, int w, int h, int data)
603
williams_state *state = space->machine().driver_data<williams_state>();
604
int source, sxadv, syadv;
605
int dest, dxadv, dyadv;
610
/* compute how much to advance in the x and y loops */
611
sxadv = (data & 0x01) ? 0x100 : 1;
612
syadv = (data & 0x01) ? 1 : w;
613
dxadv = (data & 0x02) ? 0x100 : 1;
614
dyadv = (data & 0x02) ? 1 : w;
616
/* determine the common mask */
618
if (data & 0x80) keepmask |= 0xf0;
619
if (data & 0x40) keepmask |= 0x0f;
620
if (keepmask == 0xff)
623
/* set the solid pixel value to the mask value */
624
solid = state->m_blitterram[1];
626
/* first case: no shifting */
629
/* loop over the height */
630
for (i = 0; i < h; i++)
632
source = sstart & 0xffff;
633
dest = dstart & 0xffff;
635
/* loop over the width */
636
for (j = w; j > 0; j--)
638
blit_pixel(space, dest, state->m_blitter_remap[space->read_byte(source)], data, keepmask, solid);
642
source = (source + sxadv) & 0xffff;
643
dest = (dest + dxadv) & 0xffff;
648
/* note that PlayBall! indicates the X coordinate doesn't wrap */
650
dstart = (dstart & 0xff00) | ((dstart + dyadv) & 0xff);
656
/* second case: shifted one pixel */
659
/* swap halves of the keep mask and the solid color */
660
keepmask = ((keepmask & 0xf0) >> 4) | ((keepmask & 0x0f) << 4);
661
solid = ((solid & 0xf0) >> 4) | ((solid & 0x0f) << 4);
663
/* loop over the height */
664
for (i = 0; i < h; i++)
668
source = sstart & 0xffff;
669
dest = dstart & 0xffff;
672
pixdata = state->m_blitter_remap[space->read_byte(source)];
673
blit_pixel(space, dest, (pixdata >> 4) & 0x0f, data, keepmask | 0xf0, solid);
676
source = (source + sxadv) & 0xffff;
677
dest = (dest + dxadv) & 0xffff;
679
/* loop over the width */
680
for (j = w - 1; j > 0; j--)
682
pixdata = (pixdata << 8) | state->m_blitter_remap[space->read_byte(source)];
683
blit_pixel(space, dest, (pixdata >> 4) & 0xff, data, keepmask, solid);
686
source = (source + sxadv) & 0xffff;
687
dest = (dest + dxadv) & 0xffff;
690
/* right edge case */
691
blit_pixel(space, dest, (pixdata << 4) & 0xf0, data, keepmask | 0x0f, solid);
696
/* note that PlayBall! indicates the X coordinate doesn't wrap */
698
dstart = (dstart & 0xff00) | ((dstart + dyadv) & 0xff);
added
removed
mess/src/mame/video/williams.c
