static VIDEO_UPDATE( alg )
{
/* composite the video */
if (!video_skip_this_frame())
{
mame_bitmap *vidbitmap;
rectangle fixedvis = Machine->screen[screen].visarea;
fixedvis.max_x++;
fixedvis.max_y++;
/* first lay down the video data */
laserdisc_get_video(discinfo, &vidbitmap);
if (video_texture == NULL)
video_texture = render_texture_alloc(vidbitmap, NULL, 0, TEXFORMAT_YUY16, NULL, NULL);
else
render_texture_set_bitmap(video_texture, vidbitmap, NULL, 0, TEXFORMAT_YUY16);
/* then overlay the Amiga video */
if (overlay_texture == NULL)
overlay_texture = render_texture_alloc(tmpbitmap, &fixedvis, 0, TEXFORMAT_PALETTEA16, NULL, NULL);
else
render_texture_set_bitmap(overlay_texture, tmpbitmap, &fixedvis, 0, TEXFORMAT_PALETTEA16);
/* add both quads to the screen */
render_screen_add_quad(0, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), video_texture, PRIMFLAG_BLENDMODE(BLENDMODE_NONE) | PRIMFLAG_SCREENTEX(1));
render_screen_add_quad(0, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), overlay_texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_SCREENTEX(1));
}
/* display disc information */
if (discinfo != NULL)
popmessage("%s", laserdisc_describe_state(discinfo));
return 0;
}
static void crosshair_init(void)
{
input_port_entry *ipt;
int player;
/* determine who needs crosshairs */
crosshair_needed = 0x00;
for (ipt = Machine->input_ports; ipt->type != IPT_END; ipt++)
if (ipt->analog.crossaxis != CROSSHAIR_AXIS_NONE)
crosshair_needed |= 1 << ipt->player;
/* all visible by default */
crosshair_visible = crosshair_needed;
/* loop over each player and load or create a bitmap */
for (player = 0; player < MAX_PLAYERS; player++)
if (crosshair_needed & (1 << player))
{
char filename[20];
/* first try to load a bitmap for the crosshair */
sprintf(filename, "cross%d.png", player);
crosshair_bitmap[player] = render_load_png(NULL, filename, NULL, NULL);
/* if that didn't work, make one up */
if (crosshair_bitmap[player] == NULL)
{
rgb_t color = crosshair_colors[player];
int x, y;
/* allocate a blank bitmap to start with */
crosshair_bitmap[player] = bitmap_alloc_format(CROSSHAIR_RAW_SIZE, CROSSHAIR_RAW_SIZE, BITMAP_FORMAT_ARGB32);
fillbitmap(crosshair_bitmap[player], MAKE_ARGB(0x00,0xff,0xff,0xff), NULL);
/* extract the raw source data to it */
for (y = 0; y < CROSSHAIR_RAW_SIZE / 2; y++)
{
/* assume it is mirrored vertically */
UINT32 *dest0 = BITMAP_ADDR32(crosshair_bitmap[player], y, 0);
UINT32 *dest1 = BITMAP_ADDR32(crosshair_bitmap[player], CROSSHAIR_RAW_SIZE - 1 - y, 0);
/* extract to two rows simultaneously */
for (x = 0; x < CROSSHAIR_RAW_SIZE; x++)
if ((crosshair_raw_top[y * CROSSHAIR_RAW_ROWBYTES + x / 8] << (x % 8)) & 0x80)
dest0[x] = dest1[x] = MAKE_ARGB(0xff,0x00,0x00,0x00) | color;
}
}
/* create a texture to reference the bitmap */
crosshair_texture[player] = render_texture_alloc(crosshair_bitmap[player], NULL, 0, TEXFORMAT_ARGB32, render_texture_hq_scale, NULL);
}
}
static void create_bitmap(running_machine *machine, int player)
{
int x, y;
char filename[20];
rgb_t color = crosshair_colors[player];
/* if we have a bitmap for this player, kill it */
if (global.bitmap[player] != NULL)
bitmap_free(global.bitmap[player]);
if (global.name[player][0] != 0)
{
/* look for user specified file */
sprintf(filename, "%s.png", global.name[player]);
global.bitmap[player] = render_load_png(OPTION_CROSSHAIRPATH, NULL, filename, NULL, NULL);
}
else
{
/* look for default cross?.png in crsshair\game dir */
sprintf(filename, "cross%d.png", player + 1);
global.bitmap[player] = render_load_png(OPTION_CROSSHAIRPATH, machine->gamedrv->name, filename, NULL, NULL);
/* look for default cross?.png in crsshair dir */
if (global.bitmap[player] == NULL)
global.bitmap[player] = render_load_png(OPTION_CROSSHAIRPATH, NULL, filename, NULL, NULL);
}
/* if that didn't work, use the built-in one */
if (global.bitmap[player] == NULL)
{
/* allocate a blank bitmap to start with */
global.bitmap[player] = bitmap_alloc(CROSSHAIR_RAW_SIZE, CROSSHAIR_RAW_SIZE, BITMAP_FORMAT_ARGB32);
bitmap_fill(global.bitmap[player], NULL, MAKE_ARGB(0x00,0xff,0xff,0xff));
/* extract the raw source data to it */
for (y = 0; y < CROSSHAIR_RAW_SIZE / 2; y++)
{
/* assume it is mirrored vertically */
UINT32 *dest0 = BITMAP_ADDR32(global.bitmap[player], y, 0);
UINT32 *dest1 = BITMAP_ADDR32(global.bitmap[player], CROSSHAIR_RAW_SIZE - 1 - y, 0);
/* extract to two rows simultaneously */
for (x = 0; x < CROSSHAIR_RAW_SIZE; x++)
if ((crosshair_raw_top[y * CROSSHAIR_RAW_ROWBYTES + x / 8] << (x % 8)) & 0x80)
dest0[x] = dest1[x] = MAKE_ARGB(0xff,0x00,0x00,0x00) | color;
}
}
/* create a texture to reference the bitmap */
global.texture[player] = render_texture_alloc(render_texture_hq_scale, NULL);
render_texture_set_bitmap(global.texture[player], global.bitmap[player], NULL, TEXFORMAT_ARGB32, NULL);
}
static VIDEO_UPDATE( cliff )
{
/* update the TMS9928A video */
video_update_tms9928a( machine, screen, bitmap, cliprect );
if (discinfo != NULL)
{
mame_bitmap *vidbitmap;
rectangle fixedvis = *TMS9928A_get_visarea();
fixedvis.max_x++;
fixedvis.max_y++;
laserdisc_get_video(discinfo, &vidbitmap);
/* first lay down the video data */
if (video_texture == NULL)
video_texture = render_texture_alloc(NULL, NULL);
if (vidbitmap != last_video_bitmap)
render_texture_set_bitmap(video_texture, vidbitmap, NULL, 0, TEXFORMAT_YUY16);
last_video_bitmap = vidbitmap;
/* then overlay the TMS9928A video */
if (overlay_texture == NULL)
overlay_texture = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(overlay_texture, bitmap, &fixedvis, 0, TEXFORMAT_PALETTEA16);
/* add both quads to the screen */
render_container_empty(render_container_get_screen(screen));
render_screen_add_quad(screen, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), video_texture, PRIMFLAG_BLENDMODE(BLENDMODE_NONE) | PRIMFLAG_SCREENTEX(1));
render_screen_add_quad(screen, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), overlay_texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_SCREENTEX(1));
}
/* display disc information */
if (discinfo != NULL)
popmessage("%s", laserdisc_describe_state(discinfo));
return 0;
}
static void gfxset_update_bitmap(running_machine *machine, ui_gfx_state *state, int xcells, int ycells, gfx_element *gfx)
{
int set = state->gfxset.set;
int cellxpix, cellypix;
int x, y;
/* compute the number of source pixels in a cell */
cellxpix = 1 + ((state->gfxset.rotate[set] & ORIENTATION_SWAP_XY) ? gfx->height : gfx->width);
cellypix = 1 + ((state->gfxset.rotate[set] & ORIENTATION_SWAP_XY) ? gfx->width : gfx->height);
/* realloc the bitmap if it is too small */
if (state->bitmap == NULL || state->texture == NULL || state->bitmap->bpp != 32 || state->bitmap->width != cellxpix * xcells || state->bitmap->height != cellypix * ycells)
{
/* free the old stuff */
if (state->texture != NULL)
render_texture_free(state->texture);
if (state->bitmap != NULL)
bitmap_free(state->bitmap);
/* allocate new stuff */
state->bitmap = bitmap_alloc(cellxpix * xcells, cellypix * ycells, BITMAP_FORMAT_ARGB32);
state->texture = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(state->texture, state->bitmap, NULL, TEXFORMAT_ARGB32, NULL);
/* force a redraw */
state->bitmap_dirty = TRUE;
}
/* handle the redraw */
if (state->bitmap_dirty)
{
/* loop over rows */
for (y = 0; y < ycells; y++)
{
rectangle cellbounds;
/* make a rect that covers this row */
cellbounds.min_x = 0;
cellbounds.max_x = state->bitmap->width - 1;
cellbounds.min_y = y * cellypix;
cellbounds.max_y = (y + 1) * cellypix - 1;
/* only display if there is data to show */
if (state->gfxset.offset[set] + y * xcells < gfx->total_elements)
{
/* draw the individual cells */
for (x = 0; x < xcells; x++)
{
int index = state->gfxset.offset[set] + y * xcells + x;
/* update the bounds for this cell */
cellbounds.min_x = x * cellxpix;
cellbounds.max_x = (x + 1) * cellxpix - 1;
/* only render if there is data */
if (index < gfx->total_elements)
gfxset_draw_item(machine, gfx, index, state->bitmap, cellbounds.min_x, cellbounds.min_y, state->gfxset.color[set], state->gfxset.rotate[set]);
/* otherwise, fill with transparency */
else
bitmap_fill(state->bitmap, &cellbounds, 0);
}
}
/* otherwise, fill with transparency */
else
bitmap_fill(state->bitmap, &cellbounds, 0);
}
/* reset the texture to force an update */
render_texture_set_bitmap(state->texture, state->bitmap, NULL, TEXFORMAT_ARGB32, NULL);
state->bitmap_dirty = FALSE;
}
}
void video_screen_configure(int scrnum, int width, int height, const rectangle *visarea, float refresh)
{
const screen_config *config = &Machine->drv->screen[scrnum];
screen_state *state = &Machine->screen[scrnum];
internal_screen_info *info = &scrinfo[scrnum];
mame_time timeval;
/* reallocate bitmap if necessary */
if (!(Machine->drv->video_attributes & VIDEO_TYPE_VECTOR))
{
int curwidth = 0, curheight = 0;
/* reality checks */
if (visarea->min_x < 0 || visarea->min_y < 0 || visarea->max_x >= width || visarea->max_y >= height)
fatalerror("video_screen_configure(): visible area must be contained within the width/height!");
/* extract the current width/height from the bitmap */
if (info->bitmap[0] != NULL)
{
curwidth = info->bitmap[0]->width;
curheight = info->bitmap[0]->height;
}
/* if we're too small to contain this width/height, reallocate our bitmaps and textures */
if (width > curwidth || height > curheight)
{
mame_bitmap_format screen_format = state->format;
/* free what we have currently */
if (info->texture != NULL)
render_texture_free(info->texture);
if (info->bitmap[0] != NULL)
bitmap_free(info->bitmap[0]);
if (info->bitmap[1] != NULL)
bitmap_free(info->bitmap[1]);
/* compute new width/height */
curwidth = MAX(width, curwidth);
curheight = MAX(height, curheight);
/* choose the texture format */
/* convert the screen format to a texture format */
switch (screen_format)
{
case BITMAP_FORMAT_INDEXED16: info->format = TEXFORMAT_PALETTE16; break;
case BITMAP_FORMAT_RGB15: info->format = TEXFORMAT_RGB15; break;
case BITMAP_FORMAT_RGB32: info->format = TEXFORMAT_RGB32; break;
default: fatalerror("Invalid bitmap format!"); break;
}
/* allocate new stuff */
info->bitmap[0] = bitmap_alloc_format(curwidth, curheight, screen_format);
info->bitmap[1] = bitmap_alloc_format(curwidth, curheight, screen_format);
info->texture = render_texture_alloc(info->bitmap[0], visarea, config->palette_base, info->format, NULL, NULL);
}
}
/* now fill in the new parameters */
state->width = width;
state->height = height;
state->visarea = *visarea;
state->refresh = refresh;
/* compute timing parameters */
timeval = double_to_mame_time(TIME_IN_HZ(refresh) / (double)height);
assert(timeval.seconds == 0);
info->scantime = timeval.subseconds;
info->pixeltime = timeval.subseconds / width;
/* recompute scanline timing */
cpu_compute_scanline_timing();
}
