Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-15 18:32:02 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Plumbed machine parameters through the renderer. Removed need for

Browse Source 
deprecat.h.

Changed render_texture_set_bitmap() to accept a palette object 
instead of a palette index. The renderer remains optimized for the 
system palette but will work if objects have their own palette as 
well.

Changed renderer to permit palettes for RGB and YUY textures. If
specified, these palettes specify a 32-entry (RGB15) or 256-entry
(others) lookup for applying additional brightness/contrast/gamma
on a per-texture basis.

Removed rescale notification. It never really worked that well and 
violated proper layering.

Renamed palette_set_brightness() to palette_set_pen_contrast() for 
clarity.

Changed palette objects to support global brightness/contrast/gamma
in addition to per-group and per-entry controls.
This commit is contained in:
Aaron Giles 2008-09-29 08:02:58 +00:00
parent ef2fa89e44
commit 296347baab
20 changed files with 346 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/emu/crsshair.c
View File

@ -170,7 +170,7 @@ static void create_bitmap(int player)
/* create a texture to reference the bitmap */ /* create a texture to reference the bitmap */
global.texture[player] = render_texture_alloc(render_texture_hq_scale, NULL); global.texture[player] = render_texture_alloc(render_texture_hq_scale, NULL);
render_texture_set_bitmap(global.texture[player], global.bitmap[player], NULL, 0, TEXFORMAT_ARGB32); render_texture_set_bitmap(global.texture[player], global.bitmap[player], NULL, TEXFORMAT_ARGB32, NULL);
} }
} }

6
src/emu/emupal.h
View File

@ -225,11 +225,11 @@ INLINE rgb_t palette_get_color(running_machine *machine, pen_t pen)
/*------------------------------------------------- /*-------------------------------------------------
palette_set_brightness - set the per-pen palette_set_pen_contrast - set the per-pen
brightness factor contrast factor
-------------------------------------------------*/ -------------------------------------------------*/
INLINE void palette_set_brightness(running_machine *machine, pen_t pen, double bright) INLINE void palette_set_pen_contrast(running_machine *machine, pen_t pen, double bright)
{ {
palette_entry_set_contrast(machine->palette, pen, bright); palette_entry_set_contrast(machine->palette, pen, bright);
} }

6
src/emu/machine/ldcore.c
View File

@ -1369,15 +1369,15 @@ VIDEO_UPDATE( laserdisc )
if (overbitmap != NULL) if (overbitmap != NULL)
{ {
if (overbitmap->format == BITMAP_FORMAT_INDEXED16) if (overbitmap->format == BITMAP_FORMAT_INDEXED16)
render_texture_set_bitmap(ldcore->overtex, overbitmap, &ldcore->config.overclip, 0, TEXFORMAT_PALETTEA16); render_texture_set_bitmap(ldcore->overtex, overbitmap, &ldcore->config.overclip, TEXFORMAT_PALETTEA16, laserdisc->machine->palette);
else if (overbitmap->format == BITMAP_FORMAT_RGB32) else if (overbitmap->format == BITMAP_FORMAT_RGB32)
render_texture_set_bitmap(ldcore->overtex, overbitmap, &ldcore->config.overclip, 0, TEXFORMAT_ARGB32); render_texture_set_bitmap(ldcore->overtex, overbitmap, &ldcore->config.overclip, TEXFORMAT_ARGB32, NULL);
} }
/* get the laserdisc video */ /* get the laserdisc video */
laserdisc_get_video(laserdisc, &vidbitmap); laserdisc_get_video(laserdisc, &vidbitmap);
if (vidbitmap != NULL) if (vidbitmap != NULL)
render_texture_set_bitmap(ldcore->videotex, vidbitmap, NULL, 0, TEXFORMAT_YUY16); render_texture_set_bitmap(ldcore->videotex, vidbitmap, NULL, TEXFORMAT_YUY16, NULL);
/* reset the screen contents */ /* reset the screen contents */
render_container_empty(render_container_get_screen(screen)); render_container_empty(render_container_get_screen(screen));

254
src/emu/render.c
View File

@ -44,7 +44,6 @@
#include "config.h" #include "config.h"
#include "output.h" #include "output.h"
#include "xmlfile.h" #include "xmlfile.h"
#include "deprecat.h"
@ -55,7 +54,7 @@
#define MAX_TEXTURE_SCALES 8 #define MAX_TEXTURE_SCALES 8
#define TEXTURE_GROUP_SIZE 256 #define TEXTURE_GROUP_SIZE 256
#define NUM_PRIMLISTS 2 #define NUM_PRIMLISTS 3
#define MAX_CLEAR_EXTENTS 1000 #define MAX_CLEAR_EXTENTS 1000
@ -133,12 +132,14 @@ struct _render_texture
render_texture * base; /* pointer to base of texture group */ render_texture * base; /* pointer to base of texture group */
bitmap_t * bitmap; /* pointer to the original bitmap */ bitmap_t * bitmap; /* pointer to the original bitmap */
rectangle sbounds; /* source bounds within the bitmap */ rectangle sbounds; /* source bounds within the bitmap */
UINT32 palettebase; /* palette base within the system palette */ palette_t * palette; /* palette associated with the texture */
int format; /* format of the texture data */ int format; /* format of the texture data */
texture_scaler_func scaler; /* scaling callback */ texture_scaler_func scaler; /* scaling callback */
void * param; /* scaling callback parameter */ void * param; /* scaling callback parameter */
UINT32 curseq; /* current sequence number */ UINT32 curseq; /* current sequence number */
scaled_texture scaled[MAX_TEXTURE_SCALES]; /* array of scaled variants of this texture */ scaled_texture scaled[MAX_TEXTURE_SCALES]; /* array of scaled variants of this texture */
rgb_t * bcglookup; /* dynamically allocated B/C/G lookup table */
UINT32 bcglookup_entries; /* number of B/C/G lookup entries allocated */
}; };
@ -146,6 +147,7 @@ struct _render_texture
struct _render_target struct _render_target
{ {
render_target * next; /* keep a linked list of targets */ render_target * next; /* keep a linked list of targets */
running_machine * machine; /* pointer to the machine we are connected with */
layout_view * curview; /* current view */ layout_view * curview; /* current view */
layout_file * filelist; /* list of layout files */ layout_file * filelist; /* list of layout files */
UINT32 flags; /* creation flags */ UINT32 flags; /* creation flags */
@ -213,9 +215,6 @@ struct _render_container
static render_target *targetlist; static render_target *targetlist;
static render_target *ui_target; static render_target *ui_target;
/* notifier callbacks */
static int (*rescale_notify)(running_machine *, int, int);
/* free lists */ /* free lists */
static render_primitive *render_primitive_free_list; static render_primitive *render_primitive_free_list;
static container_item *container_item_free_list; static container_item *container_item_free_list;
@ -270,10 +269,11 @@ static void add_clear_and_optimize_primitive_list(render_target *target, render_
static void invalidate_all_render_ref(void *refptr); static void invalidate_all_render_ref(void *refptr);
/* render textures */ /* render textures */
static int render_texture_get_scaled(render_texture *texture, UINT32 dwidth, UINT32 dheight, render_texinfo *texinfo, render_ref **reflist); static int texture_get_scaled(render_texture *texture, UINT32 dwidth, UINT32 dheight, render_texinfo *texinfo, render_ref **reflist);
static const rgb_t *texture_get_adjusted_palette(render_texture *texture, render_container *container);
/* render containers */ /* render containers */
static render_container *render_container_alloc(void); static render_container *render_container_alloc(running_machine *machine);
static void render_container_free(render_container *container); static void render_container_free(render_container *container);
static container_item *render_container_item_add_generic(render_container *container, UINT8 type, float x0, float y0, float x1, float y1, rgb_t argb); static container_item *render_container_item_add_generic(render_container *container, UINT8 type, float x0, float y0, float x1, float y1, rgb_t argb);
static void render_container_overlay_scale(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param); static void render_container_overlay_scale(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param);
@ -557,12 +557,12 @@ void render_init(running_machine *machine)
ui_target = NULL; ui_target = NULL;
/* create a UI container */ /* create a UI container */
ui_container = render_container_alloc(); ui_container = render_container_alloc(machine);
/* create a container for each screen and determine its orientation */ /* create a container for each screen and determine its orientation */
for (screen = video_screen_first(machine->config); screen != NULL; screen = video_screen_next(screen)) for (screen = video_screen_first(machine->config); screen != NULL; screen = video_screen_next(screen))
{ {
render_container *screen_container = render_container_alloc(); render_container *screen_container = render_container_alloc(machine);
render_container **temp = &screen_container->next; render_container **temp = &screen_container->next;
render_container_user_settings settings; render_container_user_settings settings;
@ -946,18 +946,6 @@ static void render_save(running_machine *machine, int config_type, xml_data_node
} }
/*-------------------------------------------------
render_set_rescale_notify - set a notifier
that we call before doing long scaling
operations
-------------------------------------------------*/
void render_set_rescale_notify(running_machine *machine, int (*notifier)(running_machine *, int, int))
{
rescale_notify = notifier;
}
/*------------------------------------------------- /*-------------------------------------------------
render_is_live_screen - return if the screen render_is_live_screen - return if the screen
is 'live' is 'live'
@ -1078,7 +1066,7 @@ float render_get_ui_aspect(void)
target target
-------------------------------------------------*/ -------------------------------------------------*/
render_target *render_target_alloc(const char *layoutfile, UINT32 flags) render_target *render_target_alloc(running_machine *machine, const char *layoutfile, UINT32 flags)
{ {
render_target *target; render_target *target;
render_target **nextptr; render_target **nextptr;
@ -1093,6 +1081,7 @@ render_target *render_target_alloc(const char *layoutfile, UINT32 flags)
*nextptr = target; *nextptr = target;
/* fill in the basics with reasonable defaults */ /* fill in the basics with reasonable defaults */
target->machine = machine;
target->flags = flags; target->flags = flags;
target->width = 640; target->width = 640;
target->height = 480; target->height = 480;
@ -1112,12 +1101,12 @@ render_target *render_target_alloc(const char *layoutfile, UINT32 flags)
/* determine the base orientation based on options */ /* determine the base orientation based on options */
target->orientation = ROT0; target->orientation = ROT0;
if (!options_get_bool(mame_options(), OPTION_ROTATE)) if (!options_get_bool(mame_options(), OPTION_ROTATE))
target->base_orientation = orientation_reverse(Machine->gamedrv->flags & ORIENTATION_MASK); target->base_orientation = orientation_reverse(machine->gamedrv->flags & ORIENTATION_MASK);
/* rotate left/right */ /* rotate left/right */
if (options_get_bool(mame_options(), OPTION_ROR) || (options_get_bool(mame_options(), OPTION_AUTOROR) && (Machine->gamedrv->flags & ORIENTATION_SWAP_XY))) if (options_get_bool(mame_options(), OPTION_ROR) || (options_get_bool(mame_options(), OPTION_AUTOROR) && (machine->gamedrv->flags & ORIENTATION_SWAP_XY)))
target->base_orientation = orientation_add(ROT90, target->base_orientation); target->base_orientation = orientation_add(ROT90, target->base_orientation);
if (options_get_bool(mame_options(), OPTION_ROL) || (options_get_bool(mame_options(), OPTION_AUTOROL) && (Machine->gamedrv->flags & ORIENTATION_SWAP_XY))) if (options_get_bool(mame_options(), OPTION_ROL) || (options_get_bool(mame_options(), OPTION_AUTOROL) && (machine->gamedrv->flags & ORIENTATION_SWAP_XY)))
target->base_orientation = orientation_add(ROT270, target->base_orientation); target->base_orientation = orientation_add(ROT270, target->base_orientation);
/* flip X/Y */ /* flip X/Y */
@ -1131,7 +1120,7 @@ render_target *render_target_alloc(const char *layoutfile, UINT32 flags)
target->layerconfig = target->base_layerconfig; target->layerconfig = target->base_layerconfig;
/* allocate a lock for the primitive list */ /* allocate a lock for the primitive list */
for (listnum = 0; listnum < NUM_PRIMLISTS; listnum++) for (listnum = 0; listnum < ARRAY_LENGTH(target->primlist); listnum++)
target->primlist[listnum].lock = osd_lock_alloc(); target->primlist[listnum].lock = osd_lock_alloc();
/* load the layout files */ /* load the layout files */
@ -1166,7 +1155,7 @@ void render_target_free(render_target *target)
*curr = target->next; *curr = target->next;
/* free any primitives */ /* free any primitives */
for (listnum = 0; listnum < NUM_PRIMLISTS; listnum++) for (listnum = 0; listnum < ARRAY_LENGTH(target->primlist); listnum++)
{ {
release_render_list(&target->primlist[listnum]); release_render_list(&target->primlist[listnum]);
osd_lock_free(target->primlist[listnum].lock); osd_lock_free(target->primlist[listnum].lock);
@ -1478,7 +1467,7 @@ void render_target_get_minimum_size(render_target *target, INT32 *minwidth, INT3
for (item = target->curview->itemlist[layer]; item != NULL; item = item->next) for (item = target->curview->itemlist[layer]; item != NULL; item = item->next)
if (item->element == NULL) if (item->element == NULL)
{ {
const device_config *screen = device_list_find_by_index(Machine->config->devicelist, VIDEO_SCREEN, item->index); const device_config *screen = device_list_find_by_index(target->machine->config->devicelist, VIDEO_SCREEN, item->index);
const screen_config *scrconfig = screen->inline_config; const screen_config *scrconfig = screen->inline_config;
const rectangle vectorvis = { 0, 639, 0, 479 }; const rectangle vectorvis = { 0, 639, 0, 479 };
const rectangle *visarea = NULL; const rectangle *visarea = NULL;
@ -1486,7 +1475,7 @@ void render_target_get_minimum_size(render_target *target, INT32 *minwidth, INT3
render_bounds bounds; render_bounds bounds;
float xscale, yscale; float xscale, yscale;
/* we may be called very early, before Machine->visible_area is initialized; handle that case */ /* we may be called very early, before machine->visible_area is initialized; handle that case */
if (scrconfig->type == SCREEN_TYPE_VECTOR) if (scrconfig->type == SCREEN_TYPE_VECTOR)
visarea = &vectorvis; visarea = &vectorvis;
else if (screen->token != NULL) else if (screen->token != NULL)
@ -1551,7 +1540,7 @@ const render_primitive_list *render_target_get_primitives(render_target *target)
/* switch to the next primitive list */ /* switch to the next primitive list */
listnum = target->listindex; listnum = target->listindex;
target->listindex = (target->listindex + 1) % NUM_PRIMLISTS; target->listindex = (target->listindex + 1) % ARRAY_LENGTH(target->primlist);
osd_lock_acquire(target->primlist[listnum].lock); osd_lock_acquire(target->primlist[listnum].lock);
/* free any previous primitives */ /* free any previous primitives */
@ -1569,7 +1558,7 @@ const render_primitive_list *render_target_get_primitives(render_target *target)
root_xform.orientation = target->orientation; root_xform.orientation = target->orientation;
/* iterate over layers back-to-front, but only if we're running */ /* iterate over layers back-to-front, but only if we're running */
if (mame_get_phase(Machine) >= MAME_PHASE_RESET) if (mame_get_phase(target->machine) >= MAME_PHASE_RESET)
for (layernum = 0; layernum < ITEM_LAYER_MAX; layernum++) for (layernum = 0; layernum < ITEM_LAYER_MAX; layernum++)
{ {
int blendmode; int blendmode;
@ -1610,9 +1599,9 @@ const render_primitive_list *render_target_get_primitives(render_target *target)
state = output_get_value(item->output_name); state = output_get_value(item->output_name);
else if (item->input_tag[0] != 0) else if (item->input_tag[0] != 0)
{ {
const input_field_config *field = input_field_by_tag_and_mask(Machine->portconfig, item->input_tag, item->input_mask); const input_field_config *field = input_field_by_tag_and_mask(target->machine->portconfig, item->input_tag, item->input_mask);
if (field != NULL) if (field != NULL)
state = ((input_port_read_safe(Machine, item->input_tag, 0) ^ field->defvalue) & item->input_mask) ? 1 : 0; state = ((input_port_read_safe(target->machine, item->input_tag, 0) ^ field->defvalue) & item->input_mask) ? 1 : 0;
} }
add_element_primitives(target, &target->primlist[listnum], &item_xform, item->element, state, blendmode); add_element_primitives(target, &target->primlist[listnum], &item_xform, item->element, state, blendmode);
} }
@ -1796,7 +1785,7 @@ static int load_layout_files(render_target *target, const char *layoutfile, int
/* if there's an explicit file, load that first */ /* if there's an explicit file, load that first */
if (layoutfile != NULL) if (layoutfile != NULL)
{ {
*nextfile = layout_file_load(Machine->basename, layoutfile); *nextfile = layout_file_load(target->machine->basename, layoutfile);
if (*nextfile != NULL) if (*nextfile != NULL)
nextfile = &(*nextfile)->next; nextfile = &(*nextfile)->next;
} }
@ -1806,28 +1795,28 @@ static int load_layout_files(render_target *target, const char *layoutfile, int
return (nextfile == &target->filelist) ? 1 : 0; return (nextfile == &target->filelist) ? 1 : 0;
/* try to load a file based on the driver name */ /* try to load a file based on the driver name */
*nextfile = layout_file_load(Machine->basename, Machine->gamedrv->name); *nextfile = layout_file_load(target->machine->basename, target->machine->gamedrv->name);
if (*nextfile == NULL) if (*nextfile == NULL)
*nextfile = layout_file_load(Machine->basename, "default"); *nextfile = layout_file_load(target->machine->basename, "default");
if (*nextfile != NULL) if (*nextfile != NULL)
nextfile = &(*nextfile)->next; nextfile = &(*nextfile)->next;
/* if a default view has been specified, use that as a fallback */ /* if a default view has been specified, use that as a fallback */
if (Machine->gamedrv->default_layout != NULL) if (target->machine->gamedrv->default_layout != NULL)
{ {
*nextfile = layout_file_load(NULL, Machine->gamedrv->default_layout); *nextfile = layout_file_load(NULL, target->machine->gamedrv->default_layout);
if (*nextfile != NULL) if (*nextfile != NULL)
nextfile = &(*nextfile)->next; nextfile = &(*nextfile)->next;
} }
if (Machine->config->default_layout != NULL) if (target->machine->config->default_layout != NULL)
{ {
*nextfile = layout_file_load(NULL, Machine->config->default_layout); *nextfile = layout_file_load(NULL, target->machine->config->default_layout);
if (*nextfile != NULL) if (*nextfile != NULL)
nextfile = &(*nextfile)->next; nextfile = &(*nextfile)->next;
} }
/* try to load another file based on the parent driver name */ /* try to load another file based on the parent driver name */
cloneof = driver_get_clone(Machine->gamedrv); cloneof = driver_get_clone(target->machine->gamedrv);
if (cloneof != NULL) if (cloneof != NULL)
{ {
*nextfile = layout_file_load(cloneof->name, cloneof->name); *nextfile = layout_file_load(cloneof->name, cloneof->name);
@ -1838,9 +1827,9 @@ static int load_layout_files(render_target *target, const char *layoutfile, int
} }
/* now do the built-in layouts for single-screen games */ /* now do the built-in layouts for single-screen games */
if (video_screen_count(Machine->config) == 1) if (video_screen_count(target->machine->config) == 1)
{ {
if (Machine->gamedrv->flags & ORIENTATION_SWAP_XY) if (target->machine->gamedrv->flags & ORIENTATION_SWAP_XY)
*nextfile = layout_file_load(NULL, layout_vertical); *nextfile = layout_file_load(NULL, layout_vertical);
else else
*nextfile = layout_file_load(NULL, layout_horizont); *nextfile = layout_file_load(NULL, layout_horizont);
@ -1992,19 +1981,10 @@ static void add_container_primitives(render_target *target, render_primitive_lis
height = (finalorient & ORIENTATION_SWAP_XY) ? (prim->bounds.x1 - prim->bounds.x0) : (prim->bounds.y1 - prim->bounds.y0); height = (finalorient & ORIENTATION_SWAP_XY) ? (prim->bounds.x1 - prim->bounds.x0) : (prim->bounds.y1 - prim->bounds.y0);
width = MIN(width, target->maxtexwidth); width = MIN(width, target->maxtexwidth);
height = MIN(height, target->maxtexheight); height = MIN(height, target->maxtexheight);
if (render_texture_get_scaled(item->texture, width, height, &prim->texture, &list->reflist)) if (texture_get_scaled(item->texture, width, height, &prim->texture, &list->reflist))
{ {
/* override the palette with our adjusted palette */ /* set the palette */
switch (item->texture->format) prim->texture.palette = texture_get_adjusted_palette(item->texture, container);
{
case TEXFORMAT_PALETTE16: prim->texture.palette = &container->bcglookup[prim->texture.palette - palette_entry_list_adjusted(Machine->palette)]; break;
case TEXFORMAT_PALETTEA16: prim->texture.palette = &container->bcglookup[prim->texture.palette - palette_entry_list_adjusted(Machine->palette)]; break;
case TEXFORMAT_RGB15: prim->texture.palette = &container->bcglookup32[0]; break;
case TEXFORMAT_RGB32: prim->texture.palette = &container->bcglookup256[0]; break;
case TEXFORMAT_ARGB32: prim->texture.palette = &container->bcglookup256[0]; break;
case TEXFORMAT_YUY16: prim->texture.palette = &container->bcglookup256[0]; break;
default: assert(FALSE);
}
/* determine UV coordinates and apply clipping */ /* determine UV coordinates and apply clipping */
prim->texcoords = oriented_texcoords[finalorient]; prim->texcoords = oriented_texcoords[finalorient];
@ -2055,7 +2035,7 @@ static void add_container_primitives(render_target *target, render_primitive_lis
prim->color = container_xform.color; prim->color = container_xform.color;
width = render_round_nearest(prim->bounds.x1) - render_round_nearest(prim->bounds.x0); width = render_round_nearest(prim->bounds.x1) - render_round_nearest(prim->bounds.x0);
height = render_round_nearest(prim->bounds.y1) - render_round_nearest(prim->bounds.y0); height = render_round_nearest(prim->bounds.y1) - render_round_nearest(prim->bounds.y0);
if (render_texture_get_scaled(container->overlaytexture, if (texture_get_scaled(container->overlaytexture,
(container_xform.orientation & ORIENTATION_SWAP_XY) ? height : width, (container_xform.orientation & ORIENTATION_SWAP_XY) ? height : width,
(container_xform.orientation & ORIENTATION_SWAP_XY) ? width : height, &prim->texture, &list->reflist)) (container_xform.orientation & ORIENTATION_SWAP_XY) ? width : height, &prim->texture, &list->reflist))
{ {
@ -2111,7 +2091,7 @@ static void add_element_primitives(render_target *target, render_primitive_list
height = MIN(height, target->maxtexheight); height = MIN(height, target->maxtexheight);
/* get the scaled texture and append it */ /* get the scaled texture and append it */
if (render_texture_get_scaled(texture, width, height, &prim->texture, &list->reflist)) if (texture_get_scaled(texture, width, height, &prim->texture, &list->reflist))
{ {
/* compute the clip rect */ /* compute the clip rect */
cliprect.x0 = render_round_nearest(xform->xoffs); cliprect.x0 = render_round_nearest(xform->xoffs);
@ -2419,7 +2399,7 @@ static void invalidate_all_render_ref(void *refptr)
/* loop over targets */ /* loop over targets */
for (target = targetlist; target != NULL; target = target->next) for (target = targetlist; target != NULL; target = target->next)
for (listnum = 0; listnum < NUM_PRIMLISTS; listnum++) for (listnum = 0; listnum < ARRAY_LENGTH(target->primlist); listnum++)
{ {
render_primitive_list *list = &target->primlist[listnum]; render_primitive_list *list = &target->primlist[listnum];
osd_lock_acquire(list->lock); osd_lock_acquire(list->lock);
@ -2495,6 +2475,14 @@ void render_texture_free(render_texture *texture)
if (texture->bitmap != NULL) if (texture->bitmap != NULL)
invalidate_all_render_ref(texture->bitmap); invalidate_all_render_ref(texture->bitmap);
/* release palette references */
if (texture->palette != NULL)
palette_deref(texture->palette);
/* free any B/C/G lookup tables */
if (texture->bcglookup != NULL)
free(texture->bcglookup);
/* add ourself back to the free list */ /* add ourself back to the free list */
base_save = texture->base; base_save = texture->base;
memset(texture, 0, sizeof(*texture)); memset(texture, 0, sizeof(*texture));
@ -2509,21 +2497,34 @@ void render_texture_free(render_texture *texture)
bitmap bitmap
-------------------------------------------------*/ -------------------------------------------------*/
void render_texture_set_bitmap(render_texture *texture, bitmap_t *bitmap, const rectangle *sbounds, UINT32 palettebase, int format) void render_texture_set_bitmap(render_texture *texture, bitmap_t *bitmap, const rectangle *sbounds, int format, palette_t *palette)
{ {
int scalenum; int scalenum;
/* ensure we have a valid palette for palettized modes */
if (format == TEXFORMAT_PALETTE16 || format == TEXFORMAT_PALETTEA16)
assert(palette != NULL);
/* invalidate references to the old bitmap */ /* invalidate references to the old bitmap */
if (bitmap != texture->bitmap && texture->bitmap != NULL) if (bitmap != texture->bitmap && texture->bitmap != NULL)
invalidate_all_render_ref(texture->bitmap); invalidate_all_render_ref(texture->bitmap);
/* if the palette is different, adjust references */
if (palette != texture->palette)
{
if (texture->palette != NULL)
palette_deref(texture->palette);
if (palette != NULL)
palette_ref(palette);
}
/* set the new bitmap/palette */ /* set the new bitmap/palette */
texture->bitmap = bitmap; texture->bitmap = bitmap;
texture->sbounds.min_x = (sbounds != NULL) ? sbounds->min_x : 0; texture->sbounds.min_x = (sbounds != NULL) ? sbounds->min_x : 0;
texture->sbounds.min_y = (sbounds != NULL) ? sbounds->min_y : 0; texture->sbounds.min_y = (sbounds != NULL) ? sbounds->min_y : 0;
texture->sbounds.max_x = (sbounds != NULL) ? sbounds->max_x : (bitmap != NULL) ? bitmap->width : 1000; texture->sbounds.max_x = (sbounds != NULL) ? sbounds->max_x : (bitmap != NULL) ? bitmap->width : 1000;
texture->sbounds.max_y = (sbounds != NULL) ? sbounds->max_y : (bitmap != NULL) ? bitmap->height : 1000; texture->sbounds.max_y = (sbounds != NULL) ? sbounds->max_y : (bitmap != NULL) ? bitmap->height : 1000;
texture->palettebase = palettebase; texture->palette = palette;
texture->format = format; texture->format = format;
/* invalidate all scaled versions */ /* invalidate all scaled versions */
@ -2541,14 +2542,14 @@ void render_texture_set_bitmap(render_texture *texture, bitmap_t *bitmap, const
/*------------------------------------------------- /*-------------------------------------------------
render_texture_get_scaled - get a scaled texture_get_scaled - get a scaled
bitmap (if we can) bitmap (if we can)
-------------------------------------------------*/ -------------------------------------------------*/
static int render_texture_get_scaled(render_texture *texture, UINT32 dwidth, UINT32 dheight, render_texinfo *texinfo, render_ref **reflist) static int texture_get_scaled(render_texture *texture, UINT32 dwidth, UINT32 dheight, render_texinfo *texinfo, render_ref **reflist)
{ {
UINT8 bpp = (texture->format == TEXFORMAT_PALETTE16 || texture->format == TEXFORMAT_PALETTEA16 || texture->format == TEXFORMAT_RGB15 || texture->format == TEXFORMAT_YUY16) ? 16 : 32; UINT8 bpp = (texture->format == TEXFORMAT_PALETTE16 || texture->format == TEXFORMAT_PALETTEA16 || texture->format == TEXFORMAT_RGB15 || texture->format == TEXFORMAT_YUY16) ? 16 : 32;
const rgb_t *palbase = (texture->format == TEXFORMAT_PALETTE16 || texture->format == TEXFORMAT_PALETTEA16) ? palette_entry_list_adjusted(Machine->palette) + texture->palettebase : NULL; const rgb_t *palbase = (texture->format == TEXFORMAT_PALETTE16 || texture->format == TEXFORMAT_PALETTEA16) ? palette_entry_list_adjusted(texture->palette) : NULL;
scaled_texture *scaled = NULL; scaled_texture *scaled = NULL;
int swidth, sheight; int swidth, sheight;
int scalenum; int scalenum;
@ -2590,10 +2591,6 @@ static int render_texture_get_scaled(render_texture *texture, UINT32 dwidth, UIN
{ {
int lowest = -1; int lowest = -1;
/* ask our notifier if we can scale now */
if (rescale_notify != NULL && !(*rescale_notify)(Machine, dwidth, dheight))
return FALSE;
/* didn't find one -- take the entry with the lowest seqnum */ /* didn't find one -- take the entry with the lowest seqnum */
for (scalenum = 0; scalenum < ARRAY_LENGTH(texture->scaled); scalenum++) for (scalenum = 0; scalenum < ARRAY_LENGTH(texture->scaled); scalenum++)
if ((lowest == -1 || texture->scaled[scalenum].seqid < texture->scaled[lowest].seqid) && !has_render_ref(*reflist, texture->scaled[scalenum].bitmap)) if ((lowest == -1 || texture->scaled[scalenum].seqid < texture->scaled[lowest].seqid) && !has_render_ref(*reflist, texture->scaled[scalenum].bitmap))
@ -2640,6 +2637,119 @@ void render_texture_hq_scale(bitmap_t *dest, const bitmap_t *source, const recta
} }
/*-------------------------------------------------
texture_get_adjusted_palette - return the
adjusted palette for a texture
-------------------------------------------------*/
static const rgb_t *texture_get_adjusted_palette(render_texture *texture, render_container *container)
{
const rgb_t *adjusted;
int numentries;
int index;
/* override the palette with our adjusted palette */
switch (texture->format)
{
case TEXFORMAT_PALETTE16:
case TEXFORMAT_PALETTEA16:
/* if no adjustment necessary, return the raw palette */
assert(texture->palette != NULL);
adjusted = palette_entry_list_adjusted(texture->palette);
if (container->brightness == 1.0f && container->contrast == 1.0f && container->gamma == 1.0f)
return adjusted;
/* if this is the machine palette, return our precomputed adjusted palette */
if (container->palclient != NULL && palette_client_get_palette(container->palclient) == texture->palette)
return container->bcglookup;
/* otherwise, ensure we have memory allocated and compute the adjusted result ourself */
numentries = palette_get_num_colors(texture->palette) * palette_get_num_groups(texture->palette);
if (texture->bcglookup == NULL || texture->bcglookup_entries < numentries)
{
texture->bcglookup = realloc(texture->bcglookup, numentries * sizeof(*texture->bcglookup));
texture->bcglookup_entries = numentries;
}
for (index = 0; index < numentries; index++)
{
UINT8 r = apply_brightness_contrast_gamma(RGB_RED(adjusted[index]), container->brightness, container->contrast, container->gamma);
UINT8 g = apply_brightness_contrast_gamma(RGB_GREEN(adjusted[index]), container->brightness, container->contrast, container->gamma);
UINT8 b = apply_brightness_contrast_gamma(RGB_BLUE(adjusted[index]), container->brightness, container->contrast, container->gamma);
texture->bcglookup[index] = MAKE_ARGB(RGB_ALPHA(adjusted[index]), r, g, b);
}
return texture->bcglookup;
case TEXFORMAT_RGB15:
/* if no adjustment necessary, return NULL */
if (container->brightness == 1.0f && container->contrast == 1.0f && container->gamma == 1.0f && texture->palette == NULL)
return NULL;
/* if no palette, return the standard lookups */
if (texture->palette == NULL)
return container->bcglookup32;
/* otherwise, ensure we have memory allocated and compute the adjusted result ourself */
assert(palette_get_num_colors(texture->palette) == 32);
adjusted = palette_entry_list_adjusted(texture->palette);
if (texture->bcglookup == NULL || texture->bcglookup_entries < 4 * 32)
{
texture->bcglookup = realloc(texture->bcglookup, 4 * 32 * sizeof(*texture->bcglookup));
texture->bcglookup_entries = 4 * 32;
}
/* otherwise, return the 32-entry BCG lookups */
for (index = 0; index < 32; index++)
{
UINT8 val = apply_brightness_contrast_gamma(RGB_GREEN(adjusted[index]), container->brightness, container->contrast, container->gamma);
texture->bcglookup[0x00 + index] = val << 0;
texture->bcglookup[0x20 + index] = val << 8;
texture->bcglookup[0x40 + index] = val << 16;
texture->bcglookup[0x60 + index] = val << 24;
}
return texture->bcglookup;
case TEXFORMAT_RGB32:
case TEXFORMAT_ARGB32:
case TEXFORMAT_YUY16:
/* if no adjustment necessary, return NULL */
if (container->brightness == 1.0f && container->contrast == 1.0f && container->gamma == 1.0f && texture->palette == NULL)
return NULL;
/* if no palette, return the standard lookups */
if (texture->palette == NULL)
return container->bcglookup256;
/* otherwise, ensure we have memory allocated and compute the adjusted result ourself */
assert(palette_get_num_colors(texture->palette) == 256);
adjusted = palette_entry_list_adjusted(texture->palette);
if (texture->bcglookup == NULL || texture->bcglookup_entries < 4 * 256)
{
texture->bcglookup = realloc(texture->bcglookup, 4 * 256 * sizeof(*texture->bcglookup));
texture->bcglookup_entries = 4 * 256;
}
/* otherwise, return the 32-entry BCG lookups */
for (index = 0; index < 256; index++)
{
UINT8 val = apply_brightness_contrast_gamma(RGB_GREEN(adjusted[index]), container->brightness, container->contrast, container->gamma);
texture->bcglookup[0x000 + index] = val << 0;
texture->bcglookup[0x100 + index] = val << 8;
texture->bcglookup[0x200 + index] = val << 16;
texture->bcglookup[0x300 + index] = val << 24;
}
return texture->bcglookup;
default:
assert(FALSE);
}
return NULL;
}
/*************************************************************************** /***************************************************************************
RENDER CONTAINERS RENDER CONTAINERS
@ -2650,7 +2760,7 @@ void render_texture_hq_scale(bitmap_t *dest, const bitmap_t *source, const recta
container container
-------------------------------------------------*/ -------------------------------------------------*/
static render_container *render_container_alloc(void) static render_container *render_container_alloc(running_machine *machine)
{ {
render_container *container; render_container *container;
int color; int color;
@ -2674,8 +2784,8 @@ static render_container *render_container_alloc(void)
render_container_empty(container); render_container_empty(container);
/* allocate a client to the main palette */ /* allocate a client to the main palette */
if (Machine->palette != NULL) if (machine->palette != NULL)
container->palclient = palette_client_alloc(Machine->palette); container->palclient = palette_client_alloc(machine->palette);
render_container_recompute_lookups(container); render_container_recompute_lookups(container);
return container; return container;
} }
@ -2788,7 +2898,7 @@ void render_container_set_overlay(render_container *container, bitmap_t *bitmap)
if (container->overlaybitmap != NULL) if (container->overlaybitmap != NULL)
{ {
container->overlaytexture = render_texture_alloc(render_container_overlay_scale, NULL); container->overlaytexture = render_texture_alloc(render_container_overlay_scale, NULL);
render_texture_set_bitmap(container->overlaytexture, bitmap, NULL, 0, TEXFORMAT_ARGB32); render_texture_set_bitmap(container->overlaytexture, bitmap, NULL, TEXFORMAT_ARGB32, NULL);
} }
} }

4
src/emu/render.h
View File

@ -350,7 +350,7 @@ int render_input_hit_test(render_target *target, INT32 target_x, INT32 target_y,
/* ----- render target management ----- */ /* ----- render target management ----- */
/* allocate a new render target */ /* allocate a new render target */
render_target *render_target_alloc(const char *layout, UINT32 flags); render_target *render_target_alloc(running_machine *machine, const char *layout, UINT32 flags);
/* free memory for a render target */ /* free memory for a render target */
void render_target_free(render_target *target); void render_target_free(render_target *target);
@ -424,7 +424,7 @@ render_texture *render_texture_alloc(texture_scaler_func scaler, void *param);
void render_texture_free(render_texture *texture); void render_texture_free(render_texture *texture);
/* set a new source bitmap */ /* set a new source bitmap */
void render_texture_set_bitmap(render_texture *texture, bitmap_t *bitmap, const rectangle *sbounds, UINT32 palettebase, int format); void render_texture_set_bitmap(render_texture *texture, bitmap_t *bitmap, const rectangle *sbounds, int format, palette_t *palette);
/* generic high quality resampling scaler */ /* generic high quality resampling scaler */
void render_texture_hq_scale(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param); void render_texture_hq_scale(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param);

2
src/emu/rendfont.c
View File

@ -276,7 +276,7 @@ static void render_font_char_expand(render_font *font, render_font_char *ch)
/* wrap a texture around the bitmap */ /* wrap a texture around the bitmap */
ch->texture = render_texture_alloc(render_texture_hq_scale, NULL); ch->texture = render_texture_alloc(render_texture_hq_scale, NULL);
render_texture_set_bitmap(ch->texture, ch->bitmap, NULL, 0, TEXFORMAT_ARGB32); render_texture_set_bitmap(ch->texture, ch->bitmap, NULL, TEXFORMAT_ARGB32, NULL);
} }

42
src/emu/ui.c
View File

@ -94,9 +94,6 @@ static rgb_t messagebox_backcolor;
static slider_state *slider_list; static slider_state *slider_list;
static slider_state *slider_current; static slider_state *slider_current;
static int display_rescale_message;
static int allow_rescale;
/*************************************************************************** /***************************************************************************
@ -104,7 +101,6 @@ static int allow_rescale;
***************************************************************************/ ***************************************************************************/
static void ui_exit(running_machine *machine); static void ui_exit(running_machine *machine);
static int rescale_notifier(running_machine *machine, int width, int height);
/* text generators */ /* text generators */
static astring *disclaimer_string(running_machine *machine, astring *buffer); static astring *disclaimer_string(running_machine *machine, astring *buffer);
@ -228,11 +224,6 @@ int ui_init(running_machine *machine)
/* reset globals */ /* reset globals */
single_step = FALSE; single_step = FALSE;
ui_set_handler(handler_messagebox, 0); ui_set_handler(handler_messagebox, 0);
/* request callbacks when the renderer does resizing */
render_set_rescale_notify(machine, rescale_notifier);
allow_rescale = 0;
display_rescale_message = FALSE;
return 0; return 0;
} }
@ -255,26 +246,6 @@ static void ui_exit(running_machine *machine)
} }
/*-------------------------------------------------
rescale_notifier - notifier to trigger a
rescale message during long operations
-------------------------------------------------*/
static int rescale_notifier(running_machine *machine, int width, int height)
{
/* always allow rescaling for a "small" area and for screenless drivers */
if (width < 500 || height < 500 || machine->primary_screen == NULL)
return TRUE;
/* if we've currently disallowed rescaling, turn on a message next frame */
if (allow_rescale == 0)
display_rescale_message = TRUE;
/* only allow rescaling once we're sure the message is visible */
return (allow_rescale == 1);
}
/*------------------------------------------------- /*-------------------------------------------------
ui_display_startup_screens - display the ui_display_startup_screens - display the
various startup screens various startup screens
@ -416,19 +387,6 @@ void ui_update_and_render(running_machine *machine)
/* cancel takes us back to the ingame handler */ /* cancel takes us back to the ingame handler */
if (ui_handler_param == UI_HANDLER_CANCEL) if (ui_handler_param == UI_HANDLER_CANCEL)
ui_set_handler(handler_ingame, 0); ui_set_handler(handler_ingame, 0);
/* add a message if we are rescaling */
if (display_rescale_message)
{
display_rescale_message = FALSE;
if (allow_rescale == 0)
allow_rescale = 2;
ui_draw_text_box("Updating Artwork...", JUSTIFY_CENTER, 0.5f, 0.5f, messagebox_backcolor);
}
/* decrement the frame counter if it is non-zero */
else if (allow_rescale != 0)
allow_rescale--;
} }

15
src/emu/uigfx.c
View File

@ -702,7 +702,7 @@ static void gfxset_update_bitmap(running_machine *machine, ui_gfx_state *state,
/* allocate new stuff */ /* allocate new stuff */
state->bitmap = bitmap_alloc(cellxpix * xcells, cellypix * ycells, BITMAP_FORMAT_ARGB32); state->bitmap = bitmap_alloc(cellxpix * xcells, cellypix * ycells, BITMAP_FORMAT_ARGB32);
state->texture = render_texture_alloc(NULL, NULL); state->texture = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(state->texture, state->bitmap, NULL, 0, TEXFORMAT_ARGB32); render_texture_set_bitmap(state->texture, state->bitmap, NULL, TEXFORMAT_ARGB32, NULL);
/* force a redraw */ /* force a redraw */
state->bitmap_dirty = TRUE; state->bitmap_dirty = TRUE;
@ -750,7 +750,7 @@ static void gfxset_update_bitmap(running_machine *machine, ui_gfx_state *state,
} }
/* reset the texture to force an update */ /* reset the texture to force an update */
render_texture_set_bitmap(state->texture, state->bitmap, NULL, 0, TEXFORMAT_ARGB32); render_texture_set_bitmap(state->texture, state->bitmap, NULL, TEXFORMAT_ARGB32, NULL);
state->bitmap_dirty = FALSE; state->bitmap_dirty = FALSE;
} }
} }
@ -1034,14 +1034,15 @@ static void tilemap_handle_keys(running_machine *machine, ui_gfx_state *state, i
static void tilemap_update_bitmap(running_machine *machine, ui_gfx_state *state, int width, int height) static void tilemap_update_bitmap(running_machine *machine, ui_gfx_state *state, int width, int height)
{ {
bitmap_format screen_format = video_screen_get_format(machine->primary_screen); bitmap_format screen_format = video_screen_get_format(machine->primary_screen);
palette_t *palette = NULL;
int screen_texformat; int screen_texformat;
/* convert the screen format to a texture format */ /* convert the screen format to a texture format */
switch (screen_format) switch (screen_format)
{ {
case BITMAP_FORMAT_INDEXED16: screen_texformat = TEXFORMAT_PALETTE16; break; case BITMAP_FORMAT_INDEXED16: screen_texformat = TEXFORMAT_PALETTE16; palette = machine->palette; break;
case BITMAP_FORMAT_RGB15: screen_texformat = TEXFORMAT_RGB15; break; case BITMAP_FORMAT_RGB15: screen_texformat = TEXFORMAT_RGB15; palette = NULL; break;
case BITMAP_FORMAT_RGB32: screen_texformat = TEXFORMAT_RGB32; break; case BITMAP_FORMAT_RGB32: screen_texformat = TEXFORMAT_RGB32; palette = NULL; break;
default: fatalerror("Invalid bitmap format!"); break; default: fatalerror("Invalid bitmap format!"); break;
} }
@ -1061,7 +1062,7 @@ static void tilemap_update_bitmap(running_machine *machine, ui_gfx_state *state,
/* allocate new stuff */ /* allocate new stuff */
state->bitmap = bitmap_alloc(width, height, screen_format); state->bitmap = bitmap_alloc(width, height, screen_format);
state->texture = render_texture_alloc(NULL, NULL); state->texture = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(state->texture, state->bitmap, NULL, 0, screen_texformat); render_texture_set_bitmap(state->texture, state->bitmap, NULL, screen_texformat, palette);
/* force a redraw */ /* force a redraw */
state->bitmap_dirty = TRUE; state->bitmap_dirty = TRUE;
@ -1073,7 +1074,7 @@ static void tilemap_update_bitmap(running_machine *machine, ui_gfx_state *state,
tilemap_draw_by_index(state->bitmap, state->tilemap.which, state->tilemap.xoffs, state->tilemap.yoffs); tilemap_draw_by_index(state->bitmap, state->tilemap.which, state->tilemap.xoffs, state->tilemap.yoffs);
/* reset the texture to force an update */ /* reset the texture to force an update */
render_texture_set_bitmap(state->texture, state->bitmap, NULL, 0, screen_texformat); render_texture_set_bitmap(state->texture, state->bitmap, NULL, screen_texformat, palette);
state->bitmap_dirty = FALSE; state->bitmap_dirty = FALSE;
} }
} }

2
src/emu/uimenu.c
View File

@ -384,7 +384,7 @@ void ui_menu_init(running_machine *machine)
*BITMAP_ADDR32(hilight_bitmap, 0, x) = MAKE_ARGB(alpha,0xff,0xff,0xff); *BITMAP_ADDR32(hilight_bitmap, 0, x) = MAKE_ARGB(alpha,0xff,0xff,0xff);
} }
hilight_texture = render_texture_alloc(NULL, NULL); hilight_texture = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(hilight_texture, hilight_bitmap, NULL, 0, TEXFORMAT_ARGB32); render_texture_set_bitmap(hilight_texture, hilight_bitmap, NULL, TEXFORMAT_ARGB32, NULL);
/* create a texture for arrow icons */ /* create a texture for arrow icons */
arrow_texture = render_texture_alloc(menu_render_triangle, NULL); arrow_texture = render_texture_alloc(menu_render_triangle, NULL);

19
src/emu/video.c
View File

@ -356,7 +356,7 @@ void video_init(running_machine *machine)
/* the native target is hard-coded to our internal layout and has all options disabled */ /* the native target is hard-coded to our internal layout and has all options disabled */
if (global.snap_native) if (global.snap_native)
{ {
global.snap_target = render_target_alloc(layout_snap, RENDER_CREATE_SINGLE_FILE | RENDER_CREATE_HIDDEN); global.snap_target = render_target_alloc(machine, layout_snap, RENDER_CREATE_SINGLE_FILE | RENDER_CREATE_HIDDEN);
assert(global.snap_target != NULL); assert(global.snap_target != NULL);
render_target_set_layer_config(global.snap_target, 0); render_target_set_layer_config(global.snap_target, 0);
} }
@ -364,7 +364,7 @@ void video_init(running_machine *machine)
/* other targets select the specified view and turn off effects */ /* other targets select the specified view and turn off effects */
else else
{ {
global.snap_target = render_target_alloc(NULL, RENDER_CREATE_HIDDEN); global.snap_target = render_target_alloc(machine, NULL, RENDER_CREATE_HIDDEN);
assert(global.snap_target != NULL); assert(global.snap_target != NULL);
render_target_set_view(global.snap_target, video_get_view_for_target(machine, global.snap_target, viewname, 0, 1)); render_target_set_view(global.snap_target, video_get_view_for_target(machine, global.snap_target, viewname, 0, 1));
render_target_set_layer_config(global.snap_target, render_target_get_layer_config(global.snap_target) & ~LAYER_CONFIG_ENABLE_SCREEN_OVERLAY); render_target_set_layer_config(global.snap_target, render_target_get_layer_config(global.snap_target) & ~LAYER_CONFIG_ENABLE_SCREEN_OVERLAY);
@ -722,6 +722,7 @@ static void realloc_screen_bitmaps(const device_config *screen)
if (state->width > curwidth || state->height > curheight) if (state->width > curwidth || state->height > curheight)
{ {
bitmap_format screen_format = config->format; bitmap_format screen_format = config->format;
palette_t *palette;
/* free what we have currently */ /* free what we have currently */
if (state->texture[0] != NULL) if (state->texture[0] != NULL)
@ -740,9 +741,9 @@ static void realloc_screen_bitmaps(const device_config *screen)
/* choose the texture format - convert the screen format to a texture format */ /* choose the texture format - convert the screen format to a texture format */
switch (screen_format) switch (screen_format)
{ {
case BITMAP_FORMAT_INDEXED16: state->texture_format = TEXFORMAT_PALETTE16; break; case BITMAP_FORMAT_INDEXED16: state->texture_format = TEXFORMAT_PALETTE16; palette = screen->machine->palette; break;
case BITMAP_FORMAT_RGB15: state->texture_format = TEXFORMAT_RGB15; break; case BITMAP_FORMAT_RGB15: state->texture_format = TEXFORMAT_RGB15; palette = NULL; break;
case BITMAP_FORMAT_RGB32: state->texture_format = TEXFORMAT_RGB32; break; case BITMAP_FORMAT_RGB32: state->texture_format = TEXFORMAT_RGB32; palette = NULL; break;
default: fatalerror("Invalid bitmap format!"); break; default: fatalerror("Invalid bitmap format!"); break;
} }
@ -754,9 +755,9 @@ static void realloc_screen_bitmaps(const device_config *screen)
/* allocate textures */ /* allocate textures */
state->texture[0] = render_texture_alloc(NULL, NULL); state->texture[0] = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(state->texture[0], state->bitmap[0], &state->visarea, 0, state->texture_format); render_texture_set_bitmap(state->texture[0], state->bitmap[0], &state->visarea, state->texture_format, palette);
state->texture[1] = render_texture_alloc(NULL, NULL); state->texture[1] = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(state->texture[1], state->bitmap[1], &state->visarea, 0, state->texture_format); render_texture_set_bitmap(state->texture[1], state->bitmap[1], &state->visarea, state->texture_format, palette);
} }
} }
} }
@ -1572,9 +1573,11 @@ static int finish_screen_updates(running_machine *machine)
{ {
bitmap_t *bitmap = state->bitmap[state->curbitmap]; bitmap_t *bitmap = state->bitmap[state->curbitmap];
rectangle fixedvis = *video_screen_get_visible_area(screen); rectangle fixedvis = *video_screen_get_visible_area(screen);
palette_t *palette = (state->texture_format == TEXFORMAT_PALETTE16) ? machine->palette : NULL;
fixedvis.max_x++; fixedvis.max_x++;
fixedvis.max_y++; fixedvis.max_y++;
render_texture_set_bitmap(state->texture[state->curbitmap], bitmap, &fixedvis, 0, state->texture_format); render_texture_set_bitmap(state->texture[state->curbitmap], bitmap, &fixedvis, state->texture_format, palette);
state->curtexture = state->curbitmap; state->curtexture = state->curbitmap;
state->curbitmap = 1 - state->curbitmap; state->curbitmap = 1 - state->curbitmap;
} }

104
src/lib/util/palette.c
View File

@ -10,6 +10,7 @@
******************************************************************************/ ******************************************************************************/
#include "palette.h" #include "palette.h"
#include <math.h>
@ -44,6 +45,11 @@ struct _palette_t
UINT32 numcolors; /* number of colors in the palette */ UINT32 numcolors; /* number of colors in the palette */
UINT32 numgroups; /* number of groups in the palette */ UINT32 numgroups; /* number of groups in the palette */
float brightness; /* overall brightness value */
float contrast; /* overall contrast value */
float gamma; /* overall gamma value */
UINT8 gamma_map[256]; /* gamma map */
rgb_t * entry_color; /* array of raw colors */ rgb_t * entry_color; /* array of raw colors */
float * entry_contrast; /* contrast value for each entry */ float * entry_contrast; /* contrast value for each entry */
rgb_t * adjusted_color; /* array of adjusted colors */ rgb_t * adjusted_color; /* array of adjusted colors */
@ -75,11 +81,11 @@ static void update_adjusted_color(palette_t *palette, UINT32 group, UINT32 index
entry for brightness entry for brightness
-------------------------------------------------*/ -------------------------------------------------*/
INLINE rgb_t adjust_palette_entry(rgb_t entry, float brightness, float contrast) INLINE rgb_t adjust_palette_entry(rgb_t entry, float brightness, float contrast, const UINT8 *gamma_map)
{ {
int r = rgb_clamp((float)RGB_RED(entry) * contrast + brightness); int r = rgb_clamp((float)gamma_map[RGB_RED(entry)] * contrast + brightness);
int g = rgb_clamp((float)RGB_GREEN(entry) * contrast + brightness); int g = rgb_clamp((float)gamma_map[RGB_GREEN(entry)] * contrast + brightness);
int b = rgb_clamp((float)RGB_BLUE(entry) * contrast + brightness); int b = rgb_clamp((float)gamma_map[RGB_BLUE(entry)] * contrast + brightness);
int a = RGB_ALPHA(entry); int a = RGB_ALPHA(entry);
return MAKE_ARGB(a,r,g,b); return MAKE_ARGB(a,r,g,b);
} }
@ -106,6 +112,13 @@ palette_t *palette_alloc(UINT32 numcolors, UINT32 numgroups)
goto error; goto error;
memset(palette, 0, sizeof(*palette)); memset(palette, 0, sizeof(*palette));
/* initialize overall controls */
palette->brightness = 0.0f;
palette->contrast = 1.0f;
palette->gamma = 1.0f;
for (index = 0; index < 256; index++)
palette->gamma_map[index] = index;
/* allocate an array of palette entries and individual contrasts for each */ /* allocate an array of palette entries and individual contrasts for each */
palette->entry_color = malloc(sizeof(*palette->entry_color) * numcolors); palette->entry_color = malloc(sizeof(*palette->entry_color) * numcolors);
palette->entry_contrast = malloc(sizeof(*palette->entry_contrast) * numcolors); palette->entry_contrast = malloc(sizeof(*palette->entry_contrast) * numcolors);
@ -461,6 +474,81 @@ const rgb_t *palette_entry_list_adjusted_rgb15(palette_t *palette)
PALETTE ADJUSTMENTS PALETTE ADJUSTMENTS
***************************************************************************/ ***************************************************************************/
/*-------------------------------------------------
palette_set_brightness - set the overall
brightness for the palette
-------------------------------------------------*/
void palette_set_brightness(palette_t *palette, float brightness)
{
int groupnum, index;
/* convert incoming value to normalized result */
brightness = (brightness - 1.0f) * 256.0f;
/* set the global brightness if changed */
if (palette->brightness == brightness)
return;
palette->brightness = brightness;
/* update across all indices in all groups */
for (groupnum = 0; groupnum < palette->numgroups; groupnum++)
for (index = 0; index < palette->numcolors; index++)
update_adjusted_color(palette, groupnum, index);
}
/*-------------------------------------------------
palette_set_contrast - set the overall
contrast for the palette
-------------------------------------------------*/
void palette_set_contrast(palette_t *palette, float contrast)
{
int groupnum, index;
/* set the global contrast if changed */
if (palette->contrast == contrast)
return;
palette->contrast = contrast;
/* update across all indices in all groups */
for (groupnum = 0; groupnum < palette->numgroups; groupnum++)
for (index = 0; index < palette->numcolors; index++)
update_adjusted_color(palette, groupnum, index);
}
/*-------------------------------------------------
palette_set_gamma - set the overall
gamma for the palette
-------------------------------------------------*/
void palette_set_gamma(palette_t *palette, float gamma)
{
int groupnum, index;
/* set the global gamma if changed */
if (palette->gamma == gamma)
return;
palette->gamma = gamma;
/* recompute the gamma map */
gamma = 1.0f / gamma;
for (index = 0; index < 256; index++)
{
float fval = (float)index * (1.0f / 255.0f);
float fresult = pow(fval, gamma);
palette->gamma_map[index] = rgb_clamp(255.0f * fresult);
}
/* update across all indices in all groups */
for (groupnum = 0; groupnum < palette->numgroups; groupnum++)
for (index = 0; index < palette->numcolors; index++)
update_adjusted_color(palette, groupnum, index);
}
/*------------------------------------------------- /*-------------------------------------------------
palette_entry_set_contrast - set the contrast palette_entry_set_contrast - set the contrast
adjustment for a single palette index adjustment for a single palette index
@ -503,6 +591,9 @@ void palette_group_set_brightness(palette_t *palette, UINT32 group, float bright
{ {
int index; int index;
/* convert incoming value to normalized result */
brightness = (brightness - 1.0f) * 256.0f;
/* if out of range, or unchanged, ignore */ /* if out of range, or unchanged, ignore */
if (group >= palette->numgroups || palette->group_bright[group] == brightness) if (group >= palette->numgroups || palette->group_bright[group] == brightness)
return; return;
@ -632,7 +723,10 @@ static void update_adjusted_color(palette_t *palette, UINT32 group, UINT32 index
rgb_t adjusted; rgb_t adjusted;
/* compute the adjusted value */ /* compute the adjusted value */
adjusted = adjust_palette_entry(palette->entry_color[index], palette->group_bright[group], palette->group_contrast[group] * palette->entry_contrast[index]); adjusted = adjust_palette_entry(palette->entry_color[index],
palette->group_bright[group] * palette->brightness,
palette->group_contrast[group] * palette->entry_contrast[index] * palette->contrast,
palette->gamma_map);
/* if not different, ignore */ /* if not different, ignore */
if (palette->adjusted_color[finalindex] == adjusted) if (palette->adjusted_color[finalindex] == adjusted)

9
src/lib/util/palette.h
View File

@ -129,6 +129,15 @@ const rgb_t *palette_entry_list_adjusted_rgb15(palette_t *palette);
/* ----- palette adjustments ----- */ /* ----- palette adjustments ----- */
/* set the overall brightness for the palette */
void palette_set_brightness(palette_t *palette, float brightness);
/* set the overall contrast for the palette */
void palette_set_contrast(palette_t *palette, float contrast);
/* set the overall gamma for the palette */
void palette_set_gamma(palette_t *palette, float gamma);
/* set the contrast adjustment for a single palette index */ /* set the contrast adjustment for a single palette index */
void palette_entry_set_contrast(palette_t *palette, UINT32 index, float contrast); void palette_entry_set_contrast(palette_t *palette, UINT32 index, float contrast);

2
src/mame/drivers/chqflag.c
View File

@ -105,7 +105,7 @@ static WRITE8_HANDLER( chqflag_vreg_w )
/* only affect the background */ /* only affect the background */
for (i = 512;i < 1024;i++) for (i = 512;i < 1024;i++)
palette_set_brightness(machine,i,brt); palette_set_pen_contrast(machine,i,brt);
} }
//if ((data & 0xf8) && (data & 0xf8) != 0x88) //if ((data & 0xf8) && (data & 0xf8) != 0x88)

2
src/mame/drivers/mwarr.c
View File

@ -123,7 +123,7 @@ static WRITE16_HANDLER( mwarr_brightness_w )
brightness = (double)(data & 0xff); brightness = (double)(data & 0xff);
for (i=0;i<0x800;i++) for (i=0;i<0x800;i++)
{ {
palette_set_brightness(machine, i, brightness/255); palette_set_pen_contrast(machine, i, brightness/255);
} }
} }

4
src/mame/drivers/psikyo4.c
View File

@ -299,7 +299,7 @@ static WRITE32_HANDLER( ps4_screen1_brt_w )
int i; int i;
for (i = 0; i < 0x800; i++) for (i = 0; i < 0x800; i++)
palette_set_brightness(machine,i,brt1); palette_set_pen_contrast(machine,i,brt1);
oldbrt1 = brt1; oldbrt1 = brt1;
} }
@ -326,7 +326,7 @@ static WRITE32_HANDLER( ps4_screen2_brt_w )
int i; int i;
for (i = 0x800; i < 0x1000; i++) for (i = 0x800; i < 0x1000; i++)
palette_set_brightness(machine,i,brt2); palette_set_pen_contrast(machine,i,brt2);
oldbrt2 = brt2; oldbrt2 = brt2;
} }

2
src/mame/drivers/shadfrce.c
View File

@ -225,7 +225,7 @@ static WRITE16_HANDLER ( shadfrce_sound_brt_w )
double brt = (data & 0xff) / 255.0; double brt = (data & 0xff) / 255.0;
for (i = 0; i < 0x4000; i++) for (i = 0; i < 0x4000; i++)
palette_set_brightness(machine,i,brt); palette_set_pen_contrast(machine,i,brt);
} }
} }

2
src/mame/video/itech32.c
View File

@ -271,7 +271,7 @@ WRITE16_HANDLER( timekill_intensity_w )
double intensity = (double)(data & 0xff) / (double)0x60; double intensity = (double)(data & 0xff) / (double)0x60;
int i; int i;
for (i = 0; i < 8192; i++) for (i = 0; i < 8192; i++)
palette_set_brightness(machine, i, intensity); palette_set_pen_contrast(machine, i, intensity);
} }
} }

6
src/mame/video/tmnt.c
View File

@ -756,15 +756,15 @@ VIDEO_UPDATE( tmnt2 )
// dim all colors before it // dim all colors before it
for (i=0; i<cb; i++) for (i=0; i<cb; i++)
palette_set_brightness(screen->machine,i,brt); palette_set_pen_contrast(screen->machine,i,brt);
// reset all colors in range // reset all colors in range
for (i=cb; i<ce; i++) for (i=cb; i<ce; i++)
palette_set_brightness(screen->machine,i,1.0); palette_set_pen_contrast(screen->machine,i,1.0);
// dim all colors after it // dim all colors after it
for (i=ce; i<2048; i++) for (i=ce; i<2048; i++)
palette_set_brightness(screen->machine,i,brt); palette_set_pen_contrast(screen->machine,i,brt);
// toggle shadow/highlight // toggle shadow/highlight
if (~dim_c & 0x10) if (~dim_c & 0x10)

6
src/mame/video/toobin.c
View File

@ -129,9 +129,9 @@ WRITE16_HANDLER( toobin_paletteram_w )
palette_set_color(machine, offset & 0x3ff, MAKE_RGB(red, green, blue)); palette_set_color(machine, offset & 0x3ff, MAKE_RGB(red, green, blue));
if (!(newword & 0x8000)) if (!(newword & 0x8000))
palette_set_brightness(machine, offset & 0x3ff, brightness); palette_set_pen_contrast(machine, offset & 0x3ff, brightness);
else else
palette_set_brightness(machine, offset & 0x3ff, 1.0); palette_set_pen_contrast(machine, offset & 0x3ff, 1.0);
} }
} }
@ -146,7 +146,7 @@ WRITE16_HANDLER( toobin_intensity_w )
for (i = 0; i < 0x400; i++) for (i = 0; i < 0x400; i++)
if (!(paletteram16[i] & 0x8000)) if (!(paletteram16[i] & 0x8000))
palette_set_brightness(machine, i, brightness); palette_set_pen_contrast(machine, i, brightness);
} }
} }

2
src/osd/windows/window.c
View File

@ -605,7 +605,7 @@ void winwindow_video_window_create(running_machine *machine, int index, win_moni
window->render_lock = osd_lock_alloc(); window->render_lock = osd_lock_alloc();
// load the layout // load the layout
window->target = render_target_alloc(NULL, 0); window->target = render_target_alloc(machine, NULL, 0);
if (window->target == NULL) if (window->target == NULL)
fatalerror("Error creating render target for window %d", index); fatalerror("Error creating render target for window %d", index);