void sega_16bit_common_base::palette_init()
{
//
// Color generation details
//
// Each color is made up of 5 bits, connected through one or more resistors like so:
//
// Bit 0 = 1 x 3.9K ohm
// Bit 1 = 1 x 2.0K ohm
// Bit 2 = 1 x 1.0K ohm
// Bit 3 = 2 x 1.0K ohm
// Bit 4 = 4 x 1.0K ohm
//
// Another data bit is connected by a tristate buffer to the color output through a
// 470 ohm resistor. The buffer allows the resistor to have no effect (tristate),
// halve brightness (pull-down) or double brightness (pull-up). The data bit source
// is bit 15 of each color RAM entry.
//
// compute weight table for regular palette entries
static const int resistances_normal[6] = { 3900, 2000, 1000, 1000/2, 1000/4, 0 };
double weights_normal[6];
compute_resistor_weights(0, 255, -1.0,
6, resistances_normal, weights_normal, 0, 0,
0, nullptr, nullptr, 0, 0,
0, nullptr, nullptr, 0, 0);
// compute weight table for shadow/hilight palette entries
static const int resistances_sh[6] = { 3900, 2000, 1000, 1000/2, 1000/4, 470 };
double weights_sh[6];
compute_resistor_weights(0, 255, -1.0,
6, resistances_sh, weights_sh, 0, 0,
0, nullptr, nullptr, 0, 0,
0, nullptr, nullptr, 0, 0);
// compute R, G, B for each weight
for (int value = 0; value < 32; value++)
{
int i4 = (value >> 4) & 1;
int i3 = (value >> 3) & 1;
int i2 = (value >> 2) & 1;
int i1 = (value >> 1) & 1;
int i0 = (value >> 0) & 1;
m_palette_normal[value] = combine_weights(weights_normal, i0, i1, i2, i3, i4, 0);
m_palette_shadow[value] = combine_weights(weights_sh, i0, i1, i2, i3, i4, 0);
m_palette_hilight[value] = combine_weights(weights_sh, i0, i1, i2, i3, i4, 1);
}
}
void williams_state::create_palette_lookup()
{
static const int resistances_rg[3] = { 1200, 560, 330 };
static const int resistances_b[2] = { 560, 330 };
double weights_r[3], weights_g[3], weights_b[2];
int i;
/* compute palette information */
/* note that there really are pullup/pulldown resistors, but this situation is complicated */
/* by the use of transistors, so we ignore that and just use the relative resistor weights */
compute_resistor_weights(0, 255, -1.0,
3, resistances_rg, weights_r, 0, 0,
3, resistances_rg, weights_g, 0, 0,
2, resistances_b, weights_b, 0, 0);
/* build a palette lookup */
m_palette_lookup = std::make_unique<rgb_t[]>(256);
for (i = 0; i < 256; i++)
{
int r = combine_3_weights(weights_r, BIT(i,0), BIT(i,1), BIT(i,2));
int g = combine_3_weights(weights_g, BIT(i,3), BIT(i,4), BIT(i,5));
int b = combine_2_weights(weights_b, BIT(i,6), BIT(i,7));
m_palette_lookup[i] = rgb_t(r, g, b);
}
}
static void create_palette_lookup(running_machine &machine)
{
williams_state *state = machine.driver_data<williams_state>();
static const int resistances_rg[3] = { 1200, 560, 330 };
static const int resistances_b[2] = { 560, 330 };
double weights_r[3], weights_g[3], weights_b[2];
int i;
/* compute palette information */
/* note that there really are pullup/pulldown resistors, but this situation is complicated */
/* by the use of transistors, so we ignore that and just use the relative resistor weights */
compute_resistor_weights(0, 255, -1.0,
3, resistances_rg, weights_r, 0, 0,
3, resistances_rg, weights_g, 0, 0,
2, resistances_b, weights_b, 0, 0);
/* build a palette lookup */
state->m_palette_lookup = auto_alloc_array(machine, rgb_t, 256);
for (i = 0; i < 256; i++)
{
int r = combine_3_weights(weights_r, BIT(i,0), BIT(i,1), BIT(i,2));
int g = combine_3_weights(weights_g, BIT(i,3), BIT(i,4), BIT(i,5));
int b = combine_2_weights(weights_b, BIT(i,6), BIT(i,7));
state->m_palette_lookup[i] = MAKE_RGB(r, g, b);
}
}
void ettrivia_state::ettrivia_palette(palette_device &palette) const
{
uint8_t const *const color_prom = memregion("proms")->base();
static constexpr int resistances[2] = { 270, 130 };
// compute the color output resistor weights
double weights[2];
compute_resistor_weights(0, 255, -1.0,
2, resistances, weights, 0, 0,
2, resistances, weights, 0, 0,
0, nullptr, nullptr, 0, 0);
for (int i = 0; i < palette.entries(); i++)
{
int bit0, bit1;
// red component
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i+0x100], 0);
int const r = combine_weights(weights, bit0, bit1);
// green component
bit0 = BIT(color_prom[i], 2);
bit1 = BIT(color_prom[i+0x100], 2);
int const g = combine_weights(weights, bit0, bit1);
// blue component
bit0 = BIT(color_prom[i], 1);
bit1 = BIT(color_prom[i+0x100], 1);
int const b = combine_weights(weights, bit0, bit1);
palette.set_pen_color(bitswap<8>(i,5,7,6,2,1,0,4,3), rgb_t(r, g, b));
}
}
void mb_vcu_device::device_start()
{
// TODO: m_screen_tag
m_ram = make_unique_clear<UINT8[]>(0x800);
m_palram = make_unique_clear<UINT8[]>(0x100);
{
static const int resistances_r[2] = { 4700, 2200 };
static const int resistances_gb[3] = { 10000, 4700, 2200 };
/* just to calculate coefficients for later use */
compute_resistor_weights(0, 255, -1.0,
3, resistances_gb, m_weights_g, 3600, 0,
3, resistances_gb, m_weights_b, 3600, 0,
2, resistances_r, m_weights_r, 3600, 0);
}
save_item(NAME(m_status));
save_pointer(NAME(m_ram.get()), 0x800);
save_pointer(NAME(m_palram.get()), 0x100);
save_item(NAME(m_param_offset_latch));
save_item(NAME(m_xpos));
save_item(NAME(m_ypos));
save_item(NAME(m_color1));
save_item(NAME(m_color2));
save_item(NAME(m_mode));
save_item(NAME(m_pix_xsize));
save_item(NAME(m_pix_ysize));
save_item(NAME(m_vregs));
save_item(NAME(m_bk_color));
save_item(NAME(m_vbank));
save_item(NAME(m_weights_r));
save_item(NAME(m_weights_g));
save_item(NAME(m_weights_b));
}
VIDEO_START_MEMBER(gottlieb_state,screwloo)
{
static const int resistances[4] = { 2000, 1000, 470, 240 };
/* compute palette information */
/* note that there really are pullup/pulldown resistors, but this situation is complicated */
/* by the use of transistors, so we ignore that and just use the realtive resistor weights */
compute_resistor_weights(0, 255, -1.0,
4, resistances, m_weights, 180, 0,
4, resistances, m_weights, 180, 0,
4, resistances, m_weights, 180, 0);
m_transparent0 = FALSE;
/* configure the background tilemap */
m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(gottlieb_state::get_screwloo_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
m_bg_tilemap->set_transparent_pen(0);
m_bg_tilemap->set_scrolldx(0, 318 - 256);
machine().gfx[0]->set_source(m_charram);
/* save some state */
save_item(NAME(m_background_priority));
save_item(NAME(m_spritebank));
save_item(NAME(m_transparent0));
}
void divebomb_state::decode_proms(const UINT8 * rgn, int size, int index, bool inv)
{
static const int resistances[4] = { 2000, 1000, 470, 220 };
double rweights[4], gweights[4], bweights[4];
/* compute the color output resistor weights */
compute_resistor_weights(0, 255, -1.0,
4, resistances, rweights, 0, 0,
4, resistances, gweights, 0, 0,
4, resistances, bweights, 0, 0);
/* create a lookup table for the palette */
for (UINT32 i = 0; i < size; ++i)
{
UINT32 rdata = rgn[i + size*2] & 0x0f;
UINT32 r = combine_4_weights(rweights, BIT(rdata, 0), BIT(rdata, 1), BIT(rdata, 2), BIT(rdata, 3));
UINT32 gdata = rgn[i + size] & 0x0f;
UINT32 g = combine_4_weights(gweights, BIT(gdata, 0), BIT(gdata, 1), BIT(gdata, 2), BIT(gdata, 3));
UINT32 bdata = rgn[i] & 0x0f;
UINT32 b = combine_4_weights(bweights, BIT(bdata, 0), BIT(bdata, 1), BIT(bdata, 2), BIT(bdata, 3));
if (!inv)
m_palette->set_pen_color(index + i, rgb_t(r, g, b));
else
m_palette->set_pen_color(index + (i ^ 0xff), rgb_t(r, g, b));
}
}
void megazone_state::palette_init()
{
const UINT8 *color_prom = machine().root_device().memregion("proms")->base();
static const int resistances_rg[3] = { 1000, 470, 220 };
static const int resistances_b [2] = { 470, 220 };
double rweights[3], gweights[3], bweights[2];
int i;
/* compute the color output resistor weights */
compute_resistor_weights(0, 255, -1.0,
3, &resistances_rg[0], rweights, 1000, 0,
3, &resistances_rg[0], gweights, 1000, 0,
2, &resistances_b[0], bweights, 1000, 0);
/* allocate the colortable */
machine().colortable = colortable_alloc(machine(), 0x20);
/* create a lookup table for the palette */
for (i = 0; i < 0x20; i++)
{
int bit0, bit1, bit2;
int r, g, b;
/* red component */
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i], 1);
bit2 = BIT(color_prom[i], 2);
r = combine_3_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);
g = combine_3_weights(gweights, bit0, bit1, bit2);
/* blue component */
bit0 = BIT(color_prom[i], 6);
bit1 = BIT(color_prom[i], 7);
b = combine_2_weights(bweights, bit0, bit1);
colortable_palette_set_color(machine().colortable, i, MAKE_RGB(r, g, b));
}
/* color_prom now points to the beginning of the lookup table */
color_prom += 0x20;
/* sprites */
for (i = 0; i < 0x100; i++)
{
UINT8 ctabentry = color_prom[i] & 0x0f;
colortable_entry_set_value(machine().colortable, i, ctabentry);
}
/* characters */
for (i = 0x100; i < 0x200; i++)
{
UINT8 ctabentry = (color_prom[i] & 0x0f) | 0x10;
colortable_entry_set_value(machine().colortable, i, ctabentry);
}
}
void cloud9_state::video_start()
{
static const int resistances[3] = { 22000, 10000, 4700 };
/* allocate second bank of videoram */
m_videoram = std::make_unique<uint8_t[]>(0x8000);
membank("bank1")->set_base(m_videoram.get());
/* get pointers to our PROMs */
m_syncprom = memregion("proms")->base() + 0x000;
m_wpprom = memregion("proms")->base() + 0x200;
m_priprom = memregion("proms")->base() + 0x300;
/* compute the color output resistor weights at startup */
compute_resistor_weights(0, 255, -1.0,
3, resistances, m_rweights, 1000, 0,
3, resistances, m_gweights, 1000, 0,
3, resistances, m_bweights, 1000, 0);
/* allocate a bitmap for drawing sprites */
m_screen->register_screen_bitmap(m_spritebitmap);
/* register for savestates */
save_pointer(NAME(m_videoram), 0x8000);
save_item(NAME(m_bitmode_addr));
}
void m52_state::init_sprite_palette(const int *resistances_3, const int *resistances_2, double *weights_r, double *weights_g, double *weights_b, double scale)
{
const uint8_t *sprite_pal = memregion("spr_pal")->base();
const uint8_t *sprite_table = memregion("spr_clut")->base();
/* compute palette information for sprites */
compute_resistor_weights(0, 255, scale,
2, resistances_2, weights_r, 470, 0,
3, resistances_3, weights_g, 470, 0,
3, resistances_3, weights_b, 470, 0);
/* sprite palette */
for (int i = 0; i < 32; i++)
{
uint8_t promval = sprite_pal[i];
int r = combine_2_weights(weights_r, BIT(promval, 6), BIT(promval, 7));
int g = combine_3_weights(weights_g, BIT(promval, 3), BIT(promval, 4), BIT(promval, 5));
int b = combine_3_weights(weights_b, BIT(promval, 0), BIT(promval, 1), BIT(promval, 2));
m_sp_palette->set_indirect_color(i, rgb_t(r, g, b));
}
/* sprite lookup table */
for (int i = 0; i < 256; i++)
{
uint8_t promval = sprite_table[i];
m_sp_palette->set_pen_indirect(i, promval);
}
}
void spacefb_state::video_start()
{
int width, height;
/* compute the color gun weights */
static const int resistances_rg[] = { 1000, 470, 220 };
static const int resistances_b [] = { 470, 220 };
compute_resistor_weights(0, 0xff, -1.0,
3, resistances_rg, m_color_weights_rg, 470, 0,
2, resistances_b, m_color_weights_b, 470, 0,
0, nullptr, nullptr, 0, 0);
width = m_screen->width();
height = m_screen->height();
m_object_present_map = auto_alloc_array(machine(), UINT8, width * height);
/* this start value positions the stars to match the flyer screen shot,
but most likely, the actual star position is random as the hardware
uses whatever value is on the shift register on power-up */
m_star_shift_reg = 0x18f89;
save_pointer(NAME(m_object_present_map), width * height);
save_item(NAME(m_port_0));
save_item(NAME(m_port_2));
save_item(NAME(m_star_shift_reg));
}
PALETTE_INIT_MEMBER(megazone_state, megazone)
{
const uint8_t *color_prom = memregion("proms")->base();
static const int resistances_rg[3] = { 1000, 470, 220 };
static const int resistances_b [2] = { 470, 220 };
double rweights[3], gweights[3], bweights[2];
int i;
/* compute the color output resistor weights */
compute_resistor_weights(0, 255, -1.0,
3, &resistances_rg[0], rweights, 1000, 0,
3, &resistances_rg[0], gweights, 1000, 0,
2, &resistances_b[0], bweights, 1000, 0);
/* create a lookup table for the palette */
for (i = 0; i < 0x20; i++)
{
int bit0, bit1, bit2;
int r, g, b;
/* red component */
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i], 1);
bit2 = BIT(color_prom[i], 2);
r = combine_3_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);
g = combine_3_weights(gweights, bit0, bit1, bit2);
/* blue component */
bit0 = BIT(color_prom[i], 6);
bit1 = BIT(color_prom[i], 7);
b = combine_2_weights(bweights, bit0, bit1);
palette.set_indirect_color(i, rgb_t(r, g, b));
}
/* color_prom now points to the beginning of the lookup table */
color_prom += 0x20;
/* sprites */
for (i = 0; i < 0x100; i++)
{
uint8_t ctabentry = color_prom[i] & 0x0f;
palette.set_pen_indirect(i, ctabentry);
}
/* characters */
for (i = 0x100; i < 0x200; i++)
{
uint8_t ctabentry = (color_prom[i] & 0x0f) | 0x10;
palette.set_pen_indirect(i, ctabentry);
}
}
PALETTE_INIT_MEMBER(beezer_state, beezer)
{
const int resistances_rg[3] = { 1200, 560, 330 };
const int resistances_b[2] = { 560, 330 };
// calculate coefficients for later use
compute_resistor_weights(0, 255, -1.0,
3, resistances_rg, m_weights_r, 680, 150,
3, resistances_rg, m_weights_g, 680, 150,
2, resistances_b, m_weights_b, 680, 150);
}
void mazerbla_state::mazerbla_palette(palette_device &palette)
{
static constexpr int resistances_r[2] = { 4700, 2200 };
static constexpr int resistances_gb[3] = { 10000, 4700, 2200 };
// just to calculate coefficients for later use
compute_resistor_weights(0, 255, -1.0,
3, resistances_gb, m_weights_g, 3600, 0,
3, resistances_gb, m_weights_b, 3600, 0,
2, resistances_r, m_weights_r, 3600, 0);
}
void cdp1864_device::initialize_palette()
{
const int resistances_r[] = { m_chr_r };
const int resistances_g[] = { m_chr_g };
const int resistances_b[] = { m_chr_b };
double color_weights_r[1], color_weights_g[1], color_weights_b[1];
double color_weights_bkg_r[1], color_weights_bkg_g[1], color_weights_bkg_b[1];
compute_resistor_weights(0, 0xff, -1.0,
1, resistances_r, color_weights_r, 0, m_chr_bkg,
1, resistances_g, color_weights_g, 0, m_chr_bkg,
1, resistances_b, color_weights_b, 0, m_chr_bkg);
compute_resistor_weights(0, 0xff, -1.0,
1, resistances_r, color_weights_bkg_r, m_chr_bkg, 0,
1, resistances_g, color_weights_bkg_g, m_chr_bkg, 0,
1, resistances_b, color_weights_bkg_b, m_chr_bkg, 0);
for (int i = 0; i < 8; i++)
{
// foreground colors
UINT8 r = 0, g = 0, b = 0;
if (m_chr_r != RES_INF) r = combine_1_weights(color_weights_r, BIT(i, 0));
if (m_chr_b != RES_INF) b = combine_1_weights(color_weights_b, BIT(i, 1));
if (m_chr_g != RES_INF) g = combine_1_weights(color_weights_g, BIT(i, 2));
m_palette[i] = rgb_t(r, g, b);
// background colors
r = 0, g = 0, b = 0;
if (m_chr_r != RES_INF) r = combine_1_weights(color_weights_bkg_r, BIT(i, 0));
if (m_chr_b != RES_INF) b = combine_1_weights(color_weights_bkg_b, BIT(i, 1));
if (m_chr_g != RES_INF) g = combine_1_weights(color_weights_bkg_g, BIT(i, 2));
m_palette[i + 8] = rgb_t(r, g, b);
}
}
VIDEO_START_MEMBER(foodf_state,foodf)
{
static const int resistances[3] = { 1000, 470, 220 };
/* adjust the playfield for the 8 pixel offset */
m_playfield_tilemap->set_scrollx(0, -8);
save_item(NAME(m_playfield_flip));
/* compute the color output resistor weights */
compute_resistor_weights(0, 255, -1.0,
3, &resistances[0], m_rweights, 0, 0,
3, &resistances[0], m_gweights, 0, 0,
2, &resistances[1], m_bweights, 0, 0);
}
void fortecar_state::fortecar_palette(palette_device &palette) const
{
/* Video resistors...
O1 (LS374) R1K RED
O2 (LS374) R510 RED
O3 (LS374) R220 RED
O4 (LS374) R1K GREEN
O5 (LS374) R510 GREEN
O6 (LS374) R220 GREEN
O7 (LS374) R510 BLUE
O8 (LS374) R220 BLUE
R = 82 Ohms Pull Down.
*/
static constexpr int resistances_rg[3] = { 1000, 510, 220 };
static constexpr int resistances_b [2] = { 510, 220 };
double weights_r[3], weights_g[3], weights_b[2];
compute_resistor_weights(0, 255, -1.0,
3, resistances_rg, weights_r, 82, 0,
3, resistances_rg, weights_g, 82, 0,
2, resistances_b, weights_b, 82, 0);
uint8_t const *const color_prom = memregion("proms")->base();
for (int i = 0; i < 512; i++)
{
int bit0, bit1, bit2;
// red component
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i], 1);
bit2 = BIT(color_prom[i], 2);
int const r = combine_weights(weights_r, bit0, bit1, bit2);
// green component
bit0 = BIT(color_prom[i], 3);
bit1 = BIT(color_prom[i], 4);
bit2 = BIT(color_prom[i], 5);
int const g = combine_weights(weights_g, bit0, bit1, bit2);
// blue component
bit0 = BIT(color_prom[i], 6);
bit1 = BIT(color_prom[i], 7);
int const b = combine_weights(weights_b, bit0, bit1);
palette.set_pen_color(i, rgb_t(r, g, b));
}
}
static PALETTE_INIT( mazerbla )
{
const int resistances_r[2] = { 4700, 2200 };
const int resistances_gb[3] = { 10000, 4700, 2200 };
/* just to calculate coefficients for later use */
compute_resistor_weights(0, 255, -1.0,
3, resistances_gb, weights_g, 3600, 0,
3, resistances_gb, weights_b, 3600, 0,
2, resistances_r, weights_r, 3600, 0);
}
// copied from elsewhere. surely incorrect
void dmndrby_state::dmndrby_palette(palette_device &palette) const
{
const uint8_t *color_prom = memregion("proms")->base();
static constexpr int resistances_rg[3] = { 1000, 470, 220 };
static constexpr int resistances_b [2] = { 470, 220 };
// compute the color output resistor weights
double rweights[3], gweights[3], bweights[2];
compute_resistor_weights(0, 255, -1.0,
3, &resistances_rg[0], rweights, 470, 0,
3, &resistances_rg[0], gweights, 470, 0,
2, &resistances_b[0], bweights, 470, 0);
// create a lookup table for the palette
for (int i = 0; i < 0x20; i++)
{
int bit0, bit1, bit2;
// red component */
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i], 1);
bit2 = BIT(color_prom[i], 2);
int const r = combine_3_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 const g = combine_3_weights(gweights, bit0, bit1, bit2);
// blue component
bit0 = BIT(color_prom[i], 6);
bit1 = BIT(color_prom[i], 7);
int const b = combine_2_weights(bweights, bit0, bit1);
palette.set_indirect_color(i, rgb_t(r, g, b));
}
// color_prom now points to the beginning of the lookup table
color_prom = memregion("proms2")->base();
// normal tiles use colors 0-15
for (int i = 0x000; i < 0x300; i++)
{
uint8_t ctabentry = color_prom[i];
palette.set_pen_indirect(i, ctabentry);
}
}
void tx1_sound_device::device_start()
{
static const int r0[4] = { static_cast<int>(390e3), static_cast<int>(180e3), static_cast<int>(180e3), static_cast<int>(180e3) };
static const int r1[3] = { static_cast<int>(180e3), static_cast<int>(390e3), static_cast<int>(56e3) };
static const int r2[3] = { static_cast<int>(390e3), static_cast<int>(390e3), static_cast<int>(180e3) };
/* Allocate the stream */
m_stream = machine().sound().stream_alloc(*this, 0, 2, machine().sample_rate());
m_freq_to_step = (double)(1 << TX1_FRAC) / (double)machine().sample_rate();
/* Compute the engine resistor weights */
compute_resistor_weights(0, 10000, -1.0,
4, &r0[0], m_weights0, 0, 0,
3, &r1[0], m_weights1, 0, 0,
3, &r2[0], m_weights2, 0, 0);
}
void mb_vcu_device::device_start()
{
// TODO: m_screen_tag
m_cpu = machine().device<cpu_device>(m_cpu_tag);
m_ram = auto_alloc_array_clear(machine(), UINT8, 0x800);
{
static const int resistances_r[2] = { 4700, 2200 };
static const int resistances_gb[3] = { 10000, 4700, 2200 };
/* just to calculate coefficients for later use */
compute_resistor_weights(0, 255, -1.0,
3, resistances_gb, m_weights_g, 3600, 0,
3, resistances_gb, m_weights_b, 3600, 0,
2, resistances_r, m_weights_r, 3600, 0);
}
}
GFXDECODE_END
void mrgame_state::mrgame_palette(palette_device &palette) const
{
static constexpr int resistances[3] = { 1000, 470, 220 };
uint8_t const *const color_prom = machine().root_device().memregion("proms")->base();
// compute the color output resistor weights
double rweights[3], gweights[3], bweights[2];
compute_resistor_weights(0, 255, -1.0,
3, &resistances[0], rweights, 0, 0,
3, &resistances[0], gweights, 0, 0,
2, &resistances[1], bweights, 0, 0);
// create a lookup table for the palette
for (uint8_t i = 0; i < 32; i++)
{
uint8_t bit0, bit1, bit2;
// red component
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i], 1);
bit2 = BIT(color_prom[i], 2);
uint8_t const r = combine_3_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);
uint8_t const g = combine_3_weights(gweights, bit0, bit1, bit2);
// blue component
bit0 = BIT(color_prom[i], 6);
bit1 = BIT(color_prom[i], 7);
uint8_t const b = combine_2_weights(bweights, bit0, bit1);
palette.set_pen_color(i, rgb_t(r, g, b));
palette.set_pen_color(i + 32, rgb_t(r, g, b));
}
}
GFXDECODE_END
PALETTE_INIT_MEMBER( mrgame_state, mrgame)
{
static const int resistances[3] = { 1000, 470, 220 };
double rweights[3], gweights[3], bweights[2];
uint8_t i, bit0, bit1, bit2, r, g, b;
const uint8_t *color_prom = machine().root_device().memregion("proms")->base();
/* compute the color output resistor weights */
compute_resistor_weights(0, 255, -1.0,
3, &resistances[0], rweights, 0, 0,
3, &resistances[0], gweights, 0, 0,
2, &resistances[1], bweights, 0, 0);
/* create a lookup table for the palette */
for (i = 0; i < 32; i++)
{
/* red component */
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i], 1);
bit2 = BIT(color_prom[i], 2);
r = combine_3_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);
g = combine_3_weights(gweights, bit0, bit1, bit2);
/* blue component */
bit0 = BIT(color_prom[i], 6);
bit1 = BIT(color_prom[i], 7);
b = combine_2_weights(bweights, bit0, bit1);
palette.set_pen_color(i, rgb_t(r, g, b));
palette.set_pen_color(i+32, rgb_t(r, g, b));
}
}
void gottlieb_state::video_start()
{
static const int resistances[4] = { 2000, 1000, 470, 240 };
/* compute palette information */
/* note that there really are pullup/pulldown resistors, but this situation is complicated */
/* by the use of transistors, so we ignore that and just use the realtive resistor weights */
compute_resistor_weights(0, 255, -1.0,
4, resistances, m_weights, 180, 0,
4, resistances, m_weights, 180, 0,
4, resistances, m_weights, 180, 0);
m_transparent0 = false;
/* configure the background tilemap */
m_bg_tilemap = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(gottlieb_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
m_bg_tilemap->set_transparent_pen(0);
/* save some state */
save_item(NAME(m_background_priority));
save_item(NAME(m_spritebank));
save_item(NAME(m_transparent0));
}
/* guess: use the same resistor values as Crazy Climber (needs checking on the real HW) */
PALETTE_INIT_MEMBER(nightgal_state, nightgal)
{
const uint8_t *color_prom = memregion("proms")->base();
static const int resistances_rg[3] = { 1000, 470, 220 };
static const int resistances_b [2] = { 470, 220 };
double weights_rg[3], weights_b[2];
int i;
/* compute the color output resistor weights */
compute_resistor_weights(0, 255, -1.0,
3, resistances_rg, weights_rg, 0, 0,
2, resistances_b, weights_b, 0, 0,
0, nullptr, nullptr, 0, 0);
for (i = 0; i < palette.entries(); i++)
{
int bit0, bit1, bit2;
int r, g, b;
/* red component */
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i], 1);
bit2 = BIT(color_prom[i], 2);
r = combine_3_weights(weights_rg, bit0, bit1, bit2);
/* green component */
bit0 = BIT(color_prom[i], 3);
bit1 = BIT(color_prom[i], 4);
bit2 = BIT(color_prom[i], 5);
g = combine_3_weights(weights_rg, bit0, bit1, bit2);
/* blue component */
bit0 = BIT(color_prom[i], 6);
bit1 = BIT(color_prom[i], 7);
b = combine_2_weights(weights_b, bit0, bit1);
palette.set_pen_color(i, rgb_t(r, g, b));
}
}
// guess: use the same resistor values as Crazy Climber (needs checking on the real hardware)
void jangou_state::jangou_palette(palette_device &palette) const
{
uint8_t const *const color_prom = memregion("proms")->base();
static constexpr int resistances_rg[3] = { 1000, 470, 220 };
static constexpr int resistances_b [2] = { 470, 220 };
// compute the color output resistor weights
double weights_rg[3], weights_b[2];
compute_resistor_weights(0, 255, -1.0,
3, resistances_rg, weights_rg, 0, 0,
2, resistances_b, weights_b, 0, 0,
0, nullptr, nullptr, 0, 0);
for (int i = 0;i < palette.entries(); i++)
{
int bit0, bit1, bit2;
// red component
bit0 = BIT(color_prom[i], 0);
bit1 = BIT(color_prom[i], 1);
bit2 = BIT(color_prom[i], 2);
int const r = combine_weights(weights_rg, bit0, bit1, bit2);
// green component
bit0 = BIT(color_prom[i], 3);
bit1 = BIT(color_prom[i], 4);
bit2 = BIT(color_prom[i], 5);
int const g = combine_weights(weights_rg, bit0, bit1, bit2);
// blue component
bit0 = BIT(color_prom[i], 6);
bit1 = BIT(color_prom[i], 7);
int const b = combine_weights(weights_b, bit0, bit1);
palette.set_pen_color(i, rgb_t(r, g, b));
}
}
void ccastles_state::video_start()
{
static const int resistances[3] = { 22000, 10000, 4700 };
/* get pointers to our PROMs */
m_syncprom = machine().root_device().memregion("proms")->base() + 0x000;
m_wpprom = machine().root_device().memregion("proms")->base() + 0x200;
m_priprom = machine().root_device().memregion("proms")->base() + 0x300;
/* compute the color output resistor weights at startup */
compute_resistor_weights(0, 255, -1.0,
3, resistances, m_rweights, 1000, 0,
3, resistances, m_gweights, 1000, 0,
3, resistances, m_bweights, 1000, 0);
/* allocate a bitmap for drawing sprites */
machine().primary_screen->register_screen_bitmap(m_spritebitmap);
/* register for savestates */
save_item(NAME(m_video_control));
save_item(NAME(m_bitmode_addr));
save_item(NAME(m_hscroll));
save_item(NAME(m_vscroll));
}
PALETTE_INIT_MEMBER(m52_state, m52)
{
const UINT8 *color_prom = memregion("proms")->base();
const UINT8 *char_pal = color_prom + 0x000;
const UINT8 *back_pal = color_prom + 0x200;
const UINT8 *sprite_pal = color_prom + 0x220;
const UINT8 *sprite_table = color_prom + 0x240;
static const int resistances_3[3] = { 1000, 470, 220 };
static const int resistances_2[2] = { 470, 220 };
double weights_r[3], weights_g[3], weights_b[3], scale;
int i;
/* compute palette information for characters/backgrounds */
scale = compute_resistor_weights(0, 255, -1.0,
3, resistances_3, weights_r, 0, 0,
3, resistances_3, weights_g, 0, 0,
2, resistances_2, weights_b, 0, 0);
/* character palette */
for (i = 0; i < 512; i++)
{
UINT8 promval = char_pal[i];
int r = combine_3_weights(weights_r, BIT(promval,0), BIT(promval,1), BIT(promval,2));
int g = combine_3_weights(weights_g, BIT(promval,3), BIT(promval,4), BIT(promval,5));
int b = combine_2_weights(weights_b, BIT(promval,6), BIT(promval,7));
palette.set_indirect_color(i, rgb_t(r,g,b));
}
/* background palette */
for (i = 0; i < 32; i++)
{
UINT8 promval = back_pal[i];
int r = combine_3_weights(weights_r, BIT(promval,0), BIT(promval,1), BIT(promval,2));
int g = combine_3_weights(weights_g, BIT(promval,3), BIT(promval,4), BIT(promval,5));
int b = combine_2_weights(weights_b, BIT(promval,6), BIT(promval,7));
palette.set_indirect_color(512+i, rgb_t(r,g,b));
}
/* compute palette information for sprites */
compute_resistor_weights(0, 255, scale,
2, resistances_2, weights_r, 470, 0,
3, resistances_3, weights_g, 470, 0,
3, resistances_3, weights_b, 470, 0);
/* sprite palette */
for (i = 0; i < 32; i++)
{
UINT8 promval = sprite_pal[i];
int r = combine_2_weights(weights_r, BIT(promval,6), BIT(promval,7));
int g = combine_3_weights(weights_g, BIT(promval,3), BIT(promval,4), BIT(promval,5));
int b = combine_3_weights(weights_b, BIT(promval,0), BIT(promval,1), BIT(promval,2));
palette.set_indirect_color(512 + 32 + i, rgb_t(r,g,b));
}
/* character lookup table */
for (i = 0; i < 512; i++)
palette.set_pen_indirect(i, i);
/* sprite lookup table */
for (i = 0; i < 16 * 4; i++)
{
UINT8 promval = sprite_table[(i & 3) | ((i & ~3) << 1)];
palette.set_pen_indirect(512 + i, 512 + 32 + promval);
}
/* background */
/* the palette is a 32x8 PROM with many colors repeated. The address of */
/* the colors to pick is as follows: */
/* xbb00: mountains */
/* 0xxbb: hills */
/* 1xxbb: city */
palette.set_pen_indirect(512+16*4+0*4+0, 512);
palette.set_pen_indirect(512+16*4+0*4+1, 512+4);
palette.set_pen_indirect(512+16*4+0*4+2, 512+8);
palette.set_pen_indirect(512+16*4+0*4+3, 512+12);
palette.set_pen_indirect(512+16*4+1*4+0, 512);
palette.set_pen_indirect(512+16*4+1*4+1, 512+1);
palette.set_pen_indirect(512+16*4+1*4+2, 512+2);
palette.set_pen_indirect(512+16*4+1*4+3, 512+3);
palette.set_pen_indirect(512+16*4+2*4+0, 512);
palette.set_pen_indirect(512+16*4+2*4+1, 512+16+1);
palette.set_pen_indirect(512+16*4+2*4+2, 512+16+2);
palette.set_pen_indirect(512+16*4+2*4+3, 512+16+3);
}
void lucky74_state::lucky74_palette(palette_device &palette) const
{
// There are 2 states (see the technical notes).
// We're constructing a double-sized palette with one half for each state.
uint8_t const *const color_prom = memregion("proms")->base();
static constexpr int resistances_rgb[4] = { 2000, 1000, 470, 220 };
double weights_r[4], weights_g[4], weights_b[4];
compute_resistor_weights(0, 255, -1.0,
4, resistances_rgb, weights_r, 1000, 0,
4, resistances_rgb, weights_g, 1000, 0,
4, resistances_rgb, weights_b, 1000, 0);
for (int i = 0; i < 256; i++)
{
int bit0, bit1, bit2, bit3;
// red component (this 1, PROM E6)
bit0 = BIT(color_prom[0x000 + i], 0);
bit1 = BIT(color_prom[0x000 + i], 1);
bit2 = BIT(color_prom[0x000 + i], 2);
bit3 = BIT(color_prom[0x000 + i], 3);
int const r1 = combine_weights(weights_r, bit0, bit1, bit2, bit3);
// red component (this 2, PROM E7)
bit0 = BIT(color_prom[0x100 + i], 0);
bit1 = BIT(color_prom[0x100 + i], 1);
bit2 = BIT(color_prom[0x100 + i], 2);
bit3 = BIT(color_prom[0x100 + i], 3);
int const r2 = combine_weights(weights_r, bit0, bit1, bit2, bit3);
// green component (this 1, PROM D6)
bit0 = BIT(color_prom[0x200 + i], 0);
bit1 = BIT(color_prom[0x200 + i], 1);
bit2 = BIT(color_prom[0x200 + i], 2);
bit3 = BIT(color_prom[0x200 + i], 3);
int const g1 = combine_weights(weights_g, bit0, bit1, bit2, bit3);
// green component (this 2, PROM D7)
bit0 = BIT(color_prom[0x300 + i], 0);
bit1 = BIT(color_prom[0x300 + i], 1);
bit2 = BIT(color_prom[0x300 + i], 2);
bit3 = BIT(color_prom[0x300 + i], 3);
int const g2 = combine_weights(weights_g, bit0, bit1, bit2, bit3);
// blue component (this 1, PROM C6)
bit0 = BIT(color_prom[0x400 + i], 0);
bit1 = BIT(color_prom[0x400 + i], 1);
bit2 = BIT(color_prom[0x400 + i], 2);
bit3 = BIT(color_prom[0x400 + i], 3);
int const b1 = combine_weights(weights_b, bit0, bit1, bit2, bit3);
// blue component (this 2, PROM C7)
bit0 = BIT(color_prom[0x500 + i], 0);
bit1 = BIT(color_prom[0x500 + i], 1);
bit2 = BIT(color_prom[0x500 + i], 2);
bit3 = BIT(color_prom[0x500 + i], 3);
int const b2 = combine_weights(weights_b, bit0, bit1, bit2, bit3);
// PROMs circuitry, 1st state
palette.set_pen_color(i, rgb_t(r1, g1, b1));
// PROMs circuitry, 2nd state
palette.set_pen_color(i + 256, rgb_t(r2, g2, b2));
}
}
void m52_state::init_palette()
{
constexpr int resistances_3[3] = { 1000, 470, 220 };
constexpr int resistances_2[2] = { 470, 220 };
double weights_r[3], weights_g[3], weights_b[3], scale;
/* compute palette information for characters/backgrounds */
scale = compute_resistor_weights(0, 255, -1.0,
3, resistances_3, weights_r, 0, 0,
3, resistances_3, weights_g, 0, 0,
2, resistances_2, weights_b, 0, 0);
/* character palette */
const uint8_t *char_pal = memregion("tx_pal")->base();
for (int i = 0; i < 512; i++)
{
uint8_t promval = char_pal[i];
int r = combine_3_weights(weights_r, BIT(promval, 0), BIT(promval, 1), BIT(promval, 2));
int g = combine_3_weights(weights_g, BIT(promval, 3), BIT(promval, 4), BIT(promval, 5));
int b = combine_2_weights(weights_b, BIT(promval, 6), BIT(promval, 7));
m_tx_palette->set_pen_color(i, rgb_t(r, g, b));
}
/* background palette */
const uint8_t *back_pal = memregion("bg_pal")->base();
for (int i = 0; i < 32; i++)
{
uint8_t promval = back_pal[i];
int r = combine_3_weights(weights_r, BIT(promval, 0), BIT(promval, 1), BIT(promval, 2));
int g = combine_3_weights(weights_g, BIT(promval, 3), BIT(promval, 4), BIT(promval, 5));
int b = combine_2_weights(weights_b, BIT(promval, 6), BIT(promval, 7));
m_bg_palette->set_indirect_color(i, rgb_t(r, g, b));
}
/* background
the palette is a 32x8 PROM with many colors repeated. The address of
the colors to pick is as follows:
xbb00: mountains
0xxbb: hills
1xxbb: city
this seems hacky, surely all bytes in the PROM should be used, not just picking the ones that give the colours we want?
*/
m_bg_palette->set_pen_indirect(0 * 4 + 0, 0);
m_bg_palette->set_pen_indirect(0 * 4 + 1, 4);
m_bg_palette->set_pen_indirect(0 * 4 + 2, 8);
m_bg_palette->set_pen_indirect(0 * 4 + 3, 12);
m_bg_palette->set_pen_indirect(1 * 4 + 0, 0);
m_bg_palette->set_pen_indirect(1 * 4 + 1, 1);
m_bg_palette->set_pen_indirect(1 * 4 + 2, 2);
m_bg_palette->set_pen_indirect(1 * 4 + 3, 3);
m_bg_palette->set_pen_indirect(2 * 4 + 0, 0);
m_bg_palette->set_pen_indirect(2 * 4 + 1, 16 + 1);
m_bg_palette->set_pen_indirect(2 * 4 + 2, 16 + 2);
m_bg_palette->set_pen_indirect(2 * 4 + 3, 16 + 3);
init_sprite_palette(resistances_3, resistances_2, weights_r, weights_g, weights_b, scale);
}
