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);
}
}
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 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 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);
}
}
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);
}
}
// 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);
}
}
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));
}
}
/* 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));
}
}
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 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);
}
GFXDECODE_END
/***************************************************************************
Convert the color PROMs into a more useable format.
The palette PROM is connected to the RGB output this way:
Red: 1K Bit 0
470R
220R
Green: 1K Bit 3
470R
220R
Blue: 470R
220R Bit 7
Everything is also tied to a 1K pulldown resistor
***************************************************************************/
static PALETTE_INIT( dealem )
{
const UINT8 *color_prom = machine.root_device().memregion("proms")->base();
int i, len;
static const int resistances_rg[3] = { 1000, 470, 220 };
static const int resistances_b [2] = { 470, 220 };
double weights_r[3], weights_g[3], weights_b[2];
compute_resistor_weights(0, 255, -1.0,
3, resistances_rg, weights_r, 1000, 0,
3, resistances_rg, weights_g, 1000, 0,
2, resistances_b, weights_b, 1000, 0);
len = machine.root_device().memregion("proms")->bytes();
for (i = 0; i < len; i++)
{
int bit0,bit1,bit2,r,g,b;
/* red component */
bit0 = BIT(*color_prom,0);
bit1 = BIT(*color_prom,1);
bit2 = BIT(*color_prom,2);
r = combine_3_weights(weights_r, bit0, bit1, bit2);
/* green component */
bit0 = BIT(*color_prom,3);
bit1 = BIT(*color_prom,4);
bit2 = BIT(*color_prom,5);
g = combine_3_weights(weights_g, bit0, bit1, bit2);
/* blue component */
bit0 = BIT(*color_prom,6);
bit1 = BIT(*color_prom,7);
b = combine_2_weights(weights_b, bit0, bit1);
palette_set_color(machine,i,MAKE_RGB(r,g,b));
color_prom++;
}
}
PALETTE_INIT_MEMBER(galaxian_state, galaxian)
{
const UINT8 *color_prom = memregion("proms")->base();
static const int rgb_resistances[3] = { 1000, 470, 220 };
double rweights[3], gweights[3], bweights[2];
int i, minval, midval, maxval, len;
UINT8 starmap[4];
/*
Sprite/tilemap colors are mapped through a color PROM as follows:
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
Note that not all boards have this configuration. Namco PCBs may
have 330 ohm resistors instead of 220, but the default setup has
also been used by Namco.
In parallel with these resistors are a pair of 150 ohm and 100 ohm
resistors on each R,G,B component that are connected to the star
generator.
And in parallel with the whole mess are a set of 100 ohm resistors
on each R,G,B component that are enabled when a shell/missile is
enabled.
When computing weights, we use RGB_MAXIMUM as the maximum to give
headroom for stars and shells/missiles. This is not fully accurate,
but if we included all possible sources in parallel, the brightness
of the main game would be very low to allow for all the oversaturation
of the stars and shells/missiles.
*/
compute_resistor_weights(0, RGB_MAXIMUM, -1.0,
3, &rgb_resistances[0], rweights, 470, 0,
3, &rgb_resistances[0], gweights, 470, 0,
2, &rgb_resistances[1], bweights, 470, 0);
/* decode the palette first */
len = memregion("proms")->bytes();
for (i = 0; i < len; i++)
{
UINT8 bit0, bit1, bit2, 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_pen_color(i, rgb_t(r,g,b));
}
/*
The maximum sprite/tilemap resistance is ~130 Ohms with all RGB
outputs enabled (1/(1/1000 + 1/470 + 1/220)). Since we normalized
to RGB_MAXIMUM, this maps RGB_MAXIMUM -> 130 Ohms.
The stars are at 150 Ohms for the LSB, and 100 Ohms for the MSB.
This means the 3 potential values are:
150 Ohms -> RGB_MAXIMUM * 130 / 150
100 Ohms -> RGB_MAXIMUM * 130 / 100
60 Ohms -> RGB_MAXIMUM * 130 / 60
Since we can't saturate that high, we instead approximate this
by compressing the values proportionally into the 194->255 range.
*/
minval = RGB_MAXIMUM * 130 / 150;
midval = RGB_MAXIMUM * 130 / 100;
maxval = RGB_MAXIMUM * 130 / 60;
/* compute the values for each of 4 possible star values */
starmap[0] = 0;
starmap[1] = minval;
starmap[2] = minval + (255 - minval) * (midval - minval) / (maxval - minval);
starmap[3] = 255;
/* generate the colors for the stars */
for (i = 0; i < 64; i++)
{
UINT8 bit0, bit1, r, g, b;
/* bit 5 = red @ 150 Ohm, bit 4 = red @ 100 Ohm */
bit0 = BIT(i,5);
bit1 = BIT(i,4);
r = starmap[(bit1 << 1) | bit0];
/* bit 3 = green @ 150 Ohm, bit 2 = green @ 100 Ohm */
bit0 = BIT(i,3);
bit1 = BIT(i,2);
g = starmap[(bit1 << 1) | bit0];
/* bit 1 = blue @ 150 Ohm, bit 0 = blue @ 100 Ohm */
bit0 = BIT(i,1);
bit1 = BIT(i,0);
b = starmap[(bit1 << 1) | bit0];
/* set the RGB color */
m_star_color[i] = rgb_t(r, g, b);
}
/* default bullet colors are white for the first 7, and yellow for the last one */
for (i = 0; i < 7; i++)
m_bullet_color[i] = rgb_t(0xff,0xff,0xff);
m_bullet_color[7] = rgb_t(0xff,0xff,0x00);
}
