static void video_cleanup(running_machine *machine)
{
if (video_texture != NULL)
render_texture_free(video_texture);
if (overlay_texture != NULL)
render_texture_free(overlay_texture);
}
static void video_cleanup(running_machine *machine)
{
if (video_texture != NULL)
render_texture_free(video_texture);
if (overlay_texture != NULL)
render_texture_free(overlay_texture);
laserdisc_exit(discinfo);
}
static void ui_gfx_exit(running_machine *machine)
{
/* free the texture */
if (ui_gfx.texture != NULL)
render_texture_free(ui_gfx.texture);
ui_gfx.texture = NULL;
/* free the bitmap */
if (ui_gfx.bitmap != NULL)
bitmap_free(ui_gfx.bitmap);
ui_gfx.bitmap = NULL;
}
static void crosshair_exit(running_machine &machine)
{
int player;
/* free bitmaps and textures for each player */
for (player = 0; player < MAX_PLAYERS; player++)
{
if (global.texture[player] != NULL)
render_texture_free(global.texture[player]);
global.texture[player] = NULL;
global_free(global.bitmap[player]);
global.bitmap[player] = NULL;
}
}
static void crosshair_free(void)
{
int player;
/* free bitmaps and textures for each player */
for (player = 0; player < MAX_PLAYERS; player++)
{
if (crosshair_texture[player] != NULL)
render_texture_free(crosshair_texture[player]);
crosshair_texture[player] = NULL;
if (crosshair_bitmap[player] != NULL)
bitmap_free(crosshair_bitmap[player]);
crosshair_bitmap[player] = NULL;
}
}
static void video_exit(running_machine *machine)
{
int scrnum;
int i;
/* free crosshairs */
crosshair_free();
/* stop recording any movie */
video_movie_end_recording();
/* free all the graphics elements */
for (i = 0; i < MAX_GFX_ELEMENTS; i++)
{
freegfx(machine->gfx[i]);
machine->gfx[i] = 0;
}
/* free all the textures and bitmaps */
for (scrnum = 0; scrnum < MAX_SCREENS; scrnum++)
{
internal_screen_info *info = &scrinfo[scrnum];
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]);
}
/* free the snapshot target */
if (snap_target != NULL)
render_target_free(snap_target);
if (snap_bitmap != NULL)
bitmap_free(snap_bitmap);
}
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();
}
