Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-06 10:29:38 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Cloak & Dagger video code cleanup:

Browse Source 
- resnet conversion - colors are now signficantly less saturated because of the 1K pull-ups.
  This is noticable in the agent's coat and the sky color, for example.  As far as I can tell this
  correct from the schematics.
- Added bitmap palette selection based on the 128H line.  Not sure where this is actually used in
  the game
This commit is contained in:
Zsolt Vasvari 2008-02-22 01:32:05 +00:00
parent 504337cfb1
commit 8c409c07df
1 changed files with 102 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

204
src/mame/video/cloak.c
View File

@ -5,12 +5,20 @@
***************************************************************************/
#include "driver.h"
#include "deprecat.h"
#include "video/resnet.h"
#include "cloak.h"
static mame_bitmap *tmpbitmap2;
static UINT8 x,y,bmap;
static UINT8 *tmpvideoram,*tmpvideoram2;
#define NUM_PENS (0x40)
static UINT8 bitmap_videoram_selected;
static UINT8 bitmap_videoram_address_x;
static UINT8 bitmap_videoram_address_y;
static UINT8 *bitmap_videoram1;
static UINT8 *bitmap_videoram2;
static UINT8 *current_bitmap_videoram_accessed;
static UINT8 *current_bitmap_videoram_displayed;
static UINT16 *palette_ram;
static tilemap *bg_tilemap;
@ -19,11 +27,11 @@ static tilemap *bg_tilemap;
CLOAK & DAGGER uses RAM to dynamically
create the palette. The resolution is 9 bit (3 bits per gun). The palette
contains 64 entries, but it is accessed through a memory windows 128 bytes
long: writing to the first 64 bytes sets the msb of the red component to 0,
long: writing to the first 64 bytes sets the MSB of the red component to 0,
while writing to the last 64 bytes sets it to 1.
Colors 0-15 Character mapped graphics
Colors 16-31 Bitmapped graphics (maybe 8 colors per bitmap?)
Colors 16-31 Bitmapped graphics (2 palettes selected by 128H)
Colors 32-47 Sprites
Colors 48-63 not used
@ -40,80 +48,85 @@ static tilemap *bg_tilemap;
bit 0 -- diode |< -- pullup 1 kohm -- 10 kohm resistor -- pulldown 100 pf -- BLUE
***************************************************************************/
WRITE8_HANDLER( cloak_paletteram_w )
{
int r,g,b;
int bit0,bit1,bit2;
palette_ram[offset & 0x3f] = ((offset & 0x40) << 2) | data;
}
/* a write to offset 64-127 means to set the msb of the red component */
int color = data | ((offset & 0x40) << 2);
r = (~color & 0x1c0) >> 6;
g = (~color & 0x038) >> 3;
b = (~color & 0x007);
static void set_pens(running_machine *machine)
{
static const int resistances[3] = { 10000, 4700, 2200 };
double weights[3];
int i;
// the following is WRONG! fix it
/* compute the color output resistor weights */
compute_resistor_weights(0, 255, -1.0,
3, resistances, weights, 0, 1000,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0);
bit0 = (r >> 0) & 0x01;
bit1 = (r >> 1) & 0x01;
bit2 = (r >> 2) & 0x01;
r = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
bit0 = (g >> 0) & 0x01;
bit1 = (g >> 1) & 0x01;
bit2 = (g >> 2) & 0x01;
g = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
bit0 = (b >> 0) & 0x01;
bit1 = (b >> 1) & 0x01;
bit2 = (b >> 2) & 0x01;
b = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;
for (i = 0; i < NUM_PENS; i++)
{
int r, g, b;
int bit0, bit1, bit2;
palette_set_color(Machine,offset & 0x3f,MAKE_RGB(r,g,b));
/* red component */
bit0 = (~palette_ram[i] >> 6) & 0x01;
bit1 = (~palette_ram[i] >> 7) & 0x01;
bit2 = (~palette_ram[i] >> 8) & 0x01;
r = combine_3_weights(weights, bit0, bit1, bit2);
/* green component */
bit0 = (~palette_ram[i] >> 3) & 0x01;
bit1 = (~palette_ram[i] >> 4) & 0x01;
bit2 = (~palette_ram[i] >> 5) & 0x01;
g = combine_3_weights(weights, bit0, bit1, bit2);
/* blue component */
bit0 = (~palette_ram[i] >> 0) & 0x01;
bit1 = (~palette_ram[i] >> 1) & 0x01;
bit2 = (~palette_ram[i] >> 2) & 0x01;
b = combine_3_weights(weights, bit0, bit1, bit2);
palette_set_color(machine, i, MAKE_RGB(r, g, b));
}
}
static void set_current_bitmap_videoram_pointer(void)
{
current_bitmap_videoram_accessed = bitmap_videoram_selected ? bitmap_videoram1 : bitmap_videoram2;
current_bitmap_videoram_displayed = bitmap_videoram_selected ? bitmap_videoram2 : bitmap_videoram1;
}
WRITE8_HANDLER( cloak_clearbmp_w )
{
bmap = data & 0x01;
video_screen_update_now(0);
bitmap_videoram_selected = data & 0x01;
set_current_bitmap_videoram_pointer();
if (data & 0x02) /* clear */
{
if (bmap)
{
fillbitmap(tmpbitmap, 16, &Machine->screen[0].visarea);
memset(tmpvideoram, 0, 256*256);
}
else
{
fillbitmap(tmpbitmap2, 16, &Machine->screen[0].visarea);
memset(tmpvideoram2, 0, 256*256);
}
}
memset(current_bitmap_videoram_accessed, 0, 256*256);
}
static void adjust_xy(int offset)
{
switch(offset)
switch (offset)
{
case 0x00: x--; y++; break;
case 0x01: y--; break;
case 0x02: x--; break;
case 0x04: x++; y++; break;
case 0x05: y++; break;
case 0x06: x++; break;
case 0x00: bitmap_videoram_address_x--; bitmap_videoram_address_y++; break;
case 0x01: bitmap_videoram_address_y--; break;
case 0x02: bitmap_videoram_address_x--; break;
case 0x04: bitmap_videoram_address_x++; bitmap_videoram_address_y++; break;
case 0x05: bitmap_videoram_address_y++; break;
case 0x06: bitmap_videoram_address_x++; break;
}
}
READ8_HANDLER( graph_processor_r )
{
int ret;
if (bmap)
{
ret = tmpvideoram2[y * 256 + x];
}
else
{
ret = tmpvideoram[y * 256 + x];
}
UINT8 ret = current_bitmap_videoram_accessed[(bitmap_videoram_address_y << 8) | bitmap_videoram_address_x];
adjust_xy(offset);
@ -122,25 +135,12 @@ READ8_HANDLER( graph_processor_r )
WRITE8_HANDLER( graph_processor_w )
{
int color;
switch (offset)
{
case 0x03: x = data; break;
case 0x07: y = data; break;
case 0x03: bitmap_videoram_address_x = data; break;
case 0x07: bitmap_videoram_address_y = data; break;
default:
color = data & 0x07;
if (bmap)
{
*BITMAP_ADDR16(tmpbitmap, y, (x-6)&0xff) = 16 + color;
tmpvideoram[y*256+x] = color;
}
else
{
*BITMAP_ADDR16(tmpbitmap2, y, (x-6)&0xff) = 16 + color;
tmpvideoram2[y*256+x] = color;
}
current_bitmap_videoram_accessed[(bitmap_videoram_address_y << 8) | bitmap_videoram_address_x] = data & 0x07;
adjust_xy(offset);
break;
@ -165,37 +165,37 @@ static TILE_GET_INFO( get_bg_tile_info )
SET_TILE_INFO(0, code, 0, 0);
}
static void refresh_bitmaps(void)
{
int lx,ly;
for (ly = 0; ly < 256; ly++)
{
for (lx = 0; lx < 256; lx++)
{
*BITMAP_ADDR16(tmpbitmap, ly, (lx-6)&0xff) = 16 + tmpvideoram[ly*256+lx];
*BITMAP_ADDR16(tmpbitmap2, ly, (lx-6)&0xff) = 16 + tmpvideoram2[ly*256+lx];
}
}
}
VIDEO_START( cloak )
{
bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_rows,
8, 8, 32, 32);
bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
tmpbitmap = auto_bitmap_alloc(machine->screen[0].width,machine->screen[0].height,machine->screen[0].format);
tmpbitmap2 = auto_bitmap_alloc(machine->screen[0].width,machine->screen[0].height,machine->screen[0].format);
bitmap_videoram1 = auto_malloc(256*256);
bitmap_videoram2 = auto_malloc(256*256);
palette_ram = auto_malloc(NUM_PENS * sizeof(palette_ram[0]));
tmpvideoram = auto_malloc(256*256);
tmpvideoram2 = auto_malloc(256*256);
set_current_bitmap_videoram_pointer();
state_save_register_global(x);
state_save_register_global(y);
state_save_register_global(bmap);
state_save_register_global_pointer(tmpvideoram, 256*256);
state_save_register_global_pointer(tmpvideoram2, 256*256);
state_save_register_func_postload(refresh_bitmaps);
state_save_register_global(bitmap_videoram_address_x);
state_save_register_global(bitmap_videoram_address_y);
state_save_register_global(bitmap_videoram_selected);
state_save_register_global_pointer(bitmap_videoram1, 256*256);
state_save_register_global_pointer(bitmap_videoram2, 256*256);
state_save_register_global_pointer(palette_ram, NUM_PENS);
state_save_register_func_postload(set_current_bitmap_videoram_pointer);
}
static void draw_bitmap(mame_bitmap *bitmap, const rectangle *cliprect)
{
int x, y;
for (y = cliprect->min_y; y <= cliprect->max_y; y++)
for (x = cliprect->min_x; x <= cliprect->max_x; x++)
{
pen_t pen = current_bitmap_videoram_displayed[(y << 8) | x];
if (pen)
*BITMAP_ADDR16(bitmap, y, (x - 6) & 0xff) = 0x10 | ((x & 0x80) >> 4) | pen;
}
}
static void draw_sprites(running_machine *machine, mame_bitmap *bitmap, const rectangle *cliprect)
@ -218,15 +218,15 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap, const re
flipy = !flipy;
}
drawgfx(bitmap, machine->gfx[1], code, 0, flipx, flipy,
sx, sy, cliprect, TRANSPARENCY_PEN, 0);
drawgfx(bitmap, machine->gfx[1], code, 0, flipx, flipy, sx, sy, cliprect, TRANSPARENCY_PEN, 0);
}
}
VIDEO_UPDATE( cloak )
{
set_pens(machine);
tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 0);
copybitmap_trans(bitmap, (bmap ? tmpbitmap2 : tmpbitmap),flip_screen,flip_screen,0,0,cliprect,machine->pens[16]);
draw_bitmap(bitmap, cliprect);
draw_sprites(machine, bitmap, cliprect);
return 0;
}