/*************************************************************************** * * Convert the color PROMs. * * digdug has one 32x8 palette PROM and two 256x4 color lookup table PROMs * (one for characters, one for sprites). * The palette PROM is connected to the RGB output this way: * * bit 7 -- 220 ohm resistor -- BLUE * -- 470 ohm resistor -- BLUE * -- 220 ohm resistor -- GREEN * -- 470 ohm resistor -- GREEN * -- 1 kohm resistor -- GREEN * -- 220 ohm resistor -- RED * -- 470 ohm resistor -- RED * bit 0 -- 1 kohm resistor -- RED * ***************************************************************************/ void digdug_palette(palette_device palette) { Pointer <uint8_t> color_prom = new Pointer <uint8_t>(memregion("proms").base_()); //const uint8_t *color_prom = memregion("proms")->base(); for (int i = 0; i < 32; i++) { int bit0; int bit1; int bit2; bit0 = BIT(color_prom.op, 0); bit1 = BIT(color_prom.op, 1); bit2 = BIT(color_prom.op, 2); int r = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2; bit0 = BIT(color_prom.op, 3); bit1 = BIT(color_prom.op, 4); bit2 = BIT(color_prom.op, 5); int gr = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2; bit0 = 0; bit1 = BIT(color_prom.op, 6); bit2 = BIT(color_prom.op, 7); int b = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2; palette.set_indirect_color(i, new rgb_t((u8)r, (u8)gr, (u8)b)); color_prom++; } // characters - direct mapping for (int i = 0; i < 16; i++) { palette.set_pen_indirect((pen_t)((i << 1) | 0), 0); palette.set_pen_indirect((pen_t)((i << 1) | 1), (indirect_pen_t)i); } // sprites for (int i = 0; i < 0x100; i++) { palette.set_pen_indirect((pen_t)(16 * 2 + i), (indirect_pen_t)((color_prom.op & 0x0f) | 0x10)); color_prom++; } // bg_select for (int i = 0; i < 0x100; i++) { palette.set_pen_indirect((pen_t)(16 * 2 + 256 + i), (indirect_pen_t)(color_prom.op & 0x0f)); color_prom++; } }
void _1942_palette(palette_device palette) { create_palette(palette); /* characters use palette entries 128-143 */ int colorbase = 0; Pointer <uint8_t> charlut_prom = new Pointer <uint8_t>(memregion("charprom").base_()); //const uint8_t *charlut_prom = memregion("charprom")->base(); for (int i = 0; i < 64 * 4; i++) { palette.set_pen_indirect((pen_t)(colorbase + i), (indirect_pen_t)(0x80 | charlut_prom[i])); } // background tiles use palette entries 0-63 in four banks colorbase += 64 * 4; Pointer <uint8_t> tilelut_prom = new Pointer <uint8_t>(memregion("tileprom").base_()); //const uint8_t *tilelut_prom = memregion("tileprom")->base(); for (int i = 0; i < 32 * 8; i++) { palette.set_pen_indirect((pen_t)(colorbase + 0 * 32 * 8 + i), (indirect_pen_t)(0x00 | tilelut_prom[i])); palette.set_pen_indirect((pen_t)(colorbase + 1 * 32 * 8 + i), (indirect_pen_t)(0x10 | tilelut_prom[i])); palette.set_pen_indirect((pen_t)(colorbase + 2 * 32 * 8 + i), (indirect_pen_t)(0x20 | tilelut_prom[i])); palette.set_pen_indirect((pen_t)(colorbase + 3 * 32 * 8 + i), (indirect_pen_t)(0x30 | tilelut_prom[i])); } // sprites use palette entries 64-79 colorbase += 4 * 32 * 8; Pointer <uint8_t> sprlut_prom = new Pointer <uint8_t>(memregion("sprprom").base_()); //const uint8_t *sprlut_prom = memregion("sprprom")->base(); for (int i = 0; i < 16 * 16; i++) { palette.set_pen_indirect((pen_t)(colorbase + i), (indirect_pen_t)(0x40 | sprlut_prom[i])); } }
/*************************************************************************** * * Convert the color PROMs. * * Galaga has one 32x8 palette PROM and two 256x4 color lookup table PROMs * (one for characters, one for sprites). Only the first 128 bytes of the * lookup tables seem to be used. * The palette PROM is connected to the RGB output this way: * * bit 7 -- 220 ohm resistor -- BLUE * -- 470 ohm resistor -- BLUE * -- 220 ohm resistor -- GREEN * -- 470 ohm resistor -- GREEN * -- 1 kohm resistor -- GREEN * -- 220 ohm resistor -- RED * -- 470 ohm resistor -- RED * bit 0 -- 1 kohm resistor -- RED * ***************************************************************************/ void galaga_palette(palette_device palette) { Pointer <uint8_t> color_prom = new Pointer <uint8_t>(memregion("proms").base_()); //const uint8_t *color_prom = memregion("proms")->base(); // core palette for (int i = 0; i < 32; i++) { int bit0; int bit1; int bit2; bit0 = BIT(color_prom.op, 0); bit1 = BIT(color_prom.op, 1); bit2 = BIT(color_prom.op, 2); int r = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2; bit0 = BIT(color_prom.op, 3); bit1 = BIT(color_prom.op, 4); bit2 = BIT(color_prom.op, 5); int gr = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2; bit0 = 0; bit1 = BIT(color_prom.op, 6); bit2 = BIT(color_prom.op, 7); int b = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2; palette.set_indirect_color(i, new rgb_t((u8)r, (u8)gr, (u8)b)); color_prom++; } // palette for the stars for (int i = 0; i < 64; i++) { int [] map = new int[4] { 0x00, 0x47, 0x97, 0xde }; int r = map[(i >> 0) & 0x03]; int g = map[(i >> 2) & 0x03]; int b = map[(i >> 4) & 0x03]; palette.set_indirect_color(32 + i, new rgb_t((u8)r, (u8)g, (u8)b)); } // characters for (int i = 0; i < 64 * 4; i++) { palette.set_pen_indirect((pen_t)i, (indirect_pen_t)((color_prom.op & 0x0f) | 0x10)); color_prom++; } // sprites for (int i = 0; i < 64 * 4; i++) { palette.set_pen_indirect((pen_t)(64 * 4 + i), (indirect_pen_t)((color_prom.op & 0x0f))); color_prom++; } // now the stars for (int i = 0; i < 64; i++) { palette.set_pen_indirect((pen_t)(64 * 4 + 64 * 4 + i), (indirect_pen_t)(32 + i)); } }
/*************************************************************************** * * Convert the color PROMs into a more useable format. * * Xevious has three 256x4 palette PROMs (one per gun) and four 512x4 lookup * table PROMs (two for sprites, two for background tiles; foreground * characters map directly to a palette color without using a PROM). * The palette PROMs are connected to the RGB output this way: * * bit 3 -- 220 ohm resistor -- RED/GREEN/BLUE * -- 470 ohm resistor -- RED/GREEN/BLUE * -- 1 kohm resistor -- RED/GREEN/BLUE * bit 0 -- 2.2kohm resistor -- RED/GREEN/BLUE * ***************************************************************************/ void xevious_palette(palette_device palette) { Pointer <uint8_t> color_prom = new Pointer <uint8_t>(memregion("proms").base_()); //const uint8_t *color_prom = memregion("proms")->base(); Func <int, int> TOTAL_COLORS = (int gfxn) => { return((int)(m_gfxdecode.op0.gfx(gfxn).colors() * m_gfxdecode.op0.gfx(gfxn).granularity())); }; for (int i = 0; i < 128; i++) { int bit0; int bit1; int bit2; int bit3; // red component bit0 = BIT(color_prom[0], 0); bit1 = BIT(color_prom[0], 1); bit2 = BIT(color_prom[0], 2); bit3 = BIT(color_prom[0], 3); int r = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3; // green component bit0 = BIT(color_prom[256], 0); bit1 = BIT(color_prom[256], 1); bit2 = BIT(color_prom[256], 2); bit3 = BIT(color_prom[256], 3); int gr = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3; // blue component bit0 = BIT(color_prom[2 * 256], 0); bit1 = BIT(color_prom[2 * 256], 1); bit2 = BIT(color_prom[2 * 256], 2); bit3 = BIT(color_prom[2 * 256], 3); int b = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3; palette.set_indirect_color(i, new rgb_t((u8)r, (u8)gr, (u8)b)); color_prom++; } // color 0x80 is used by sprites to mark transparency palette.set_indirect_color(0x80, new rgb_t(0, 0, 0)); color_prom += 128; // the bottom part of the PROM is unused color_prom += 2 * 256; // color_prom now points to the beginning of the lookup table // background tiles for (int i = 0; i < TOTAL_COLORS(1); i++) { palette.set_pen_indirect( (pen_t)(m_gfxdecode.op0.gfx(1).colorbase() + i), (indirect_pen_t)((color_prom[0] & 0x0f) | ((color_prom[TOTAL_COLORS(1)] & 0x0f) << 4))); color_prom++; } color_prom += TOTAL_COLORS(1); // sprites for (int i = 0; i < TOTAL_COLORS(2); i++) { int c = (color_prom[0] & 0x0f) | ((color_prom[TOTAL_COLORS(2)] & 0x0f) << 4); palette.set_pen_indirect( (pen_t)(m_gfxdecode.op0.gfx(2).colorbase() + i), (c & 0x80) != 0 ? (indirect_pen_t)(c & 0x7f) : (indirect_pen_t)0x80); color_prom++; } color_prom += TOTAL_COLORS(2); // foreground characters for (int i = 0; i < TOTAL_COLORS(0); i++) { palette.set_pen_indirect( (pen_t)(m_gfxdecode.op0.gfx(0).colorbase() + i), BIT(i, 0) != 0 ? (indirect_pen_t)(i >> 1) : (indirect_pen_t)0x80); } }
/************************************************************************* * * Namco Pac Man * ************************************************************************** * * This file is used by the Pac Man, Pengo & Jr Pac Man drivers. * * Pengo & Pac Man are almost identical, the only differences being the * extra gfx bank in Pengo, and the need to compensate for an hardware * sprite positioning "bug" in Pac Man. * * Jr Pac Man has the same sprite hardware as Pac Man, the extra bank * from Pengo and a scrolling playfield at the expense of one color per row * for the playfield so it can fit in the same amount of ram. * **************************************************************************/ /*************************************************************************** * * Convert the color PROMs into a more useable format. * * * Pac Man has a 32x8 palette PROM and a 256x4 color lookup table PROM. * * Pengo has a 32x8 palette PROM and a 1024x4 color lookup table PROM. * * The palette PROM is connected to the RGB output this way: * * bit 7 -- 220 ohm resistor -- BLUE * -- 470 ohm resistor -- BLUE * -- 220 ohm resistor -- GREEN * -- 470 ohm resistor -- GREEN * -- 1 kohm resistor -- GREEN * -- 220 ohm resistor -- RED * -- 470 ohm resistor -- RED * bit 0 -- 1 kohm resistor -- RED * * * Jr. Pac Man has two 256x4 palette PROMs (the three msb of the address are * grounded, so the effective colors are only 32) and one 256x4 color lookup * table PROM. * * The palette PROMs are connected to the RGB output this way: * * bit 3 -- 220 ohm resistor -- BLUE * -- 470 ohm resistor -- BLUE * -- 220 ohm resistor -- GREEN * bit 0 -- 470 ohm resistor -- GREEN * * bit 3 -- 1 kohm resistor -- GREEN * -- 220 ohm resistor -- RED * -- 470 ohm resistor -- RED * bit 0 -- 1 kohm resistor -- RED * ***************************************************************************/ void pacman_palette(palette_device palette) { Pointer <uint8_t> color_prom = new Pointer <uint8_t>(memregion("proms").base_()); //const uint8_t *color_prom = memregion("proms")->base(); int [] resistances3 = new int [3] { 1000, 470, 220 }; int [] resistances2 = new int [2] { 470, 220 }; // compute the color output resistor weights double [] rweights = new double[3]; double [] gweights = new double[3]; double [] bweights = new double[2]; compute_resistor_weights(0, 255, -1.0, 3, resistances3, out rweights, 0, 0, 3, resistances3, out gweights, 0, 0, 2, resistances2, out bweights, 0, 0); // create a lookup table for the palette for (int i = 0; i < 32; i++) { int bit0; int bit1; int bit2; // red component bit0 = BIT(color_prom[i], 0); bit1 = BIT(color_prom[i], 1); bit2 = BIT(color_prom[i], 2); int r = combine_weights(rweights, bit0, bit1, bit2); // green component bit0 = BIT(color_prom[i], 3); bit1 = BIT(color_prom[i], 4); bit2 = BIT(color_prom[i], 5); int gr = combine_weights(gweights, bit0, bit1, bit2); // blue component bit0 = BIT(color_prom[i], 6); bit1 = BIT(color_prom[i], 7); int b = combine_weights(bweights, bit0, bit1); palette.set_indirect_color(i, new rgb_t((uint8_t)r, (uint8_t)gr, (uint8_t)b)); } // color_prom now points to the beginning of the lookup table color_prom += 32; // allocate the colortable for (int i = 0; i < 64 * 4; i++) { uint8_t ctabentry = (uint8_t)(color_prom[i] & 0x0f); // first palette bank palette.set_pen_indirect((pen_t)i, ctabentry); // second palette bank palette.set_pen_indirect((pen_t)(i + 64 * 4), (indirect_pen_t)(0x10 + ctabentry)); } }