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

Converted render.c objects into C++ objects. Updated all callers.

Browse Source
This commit is contained in:
Aaron Giles 2010-10-13 06:20:10 +00:00
parent f391c5f8d7
commit 3beb0ec246
52 changed files with 3873 additions and 4020 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/emu/cheat.c
View File

@ -522,7 +522,7 @@ void cheat_render_text(running_machine *machine, render_container *container)
{
/* output the text */
ui_draw_text_full(container, cheatinfo->output[linenum],
0.0f, (float)linenum * ui_get_line_height(), 1.0f,
0.0f, (float)linenum * ui_get_line_height(*machine), 1.0f,
cheatinfo->justify[linenum], WRAP_NEVER, DRAW_OPAQUE,
ARGB_WHITE, ARGB_BLACK, NULL, NULL);
}
@ -901,7 +901,7 @@ static void cheat_frame(running_machine &machine)
/* set up for accumulating output */
cheatinfo->lastline = 0;
cheatinfo->numlines = floor(1.0f / ui_get_line_height());
cheatinfo->numlines = floor(1.0f / ui_get_line_height(machine));
cheatinfo->numlines = MIN(cheatinfo->numlines, ARRAY_LENGTH(cheatinfo->output));
for (linenum = 0; linenum < ARRAY_LENGTH(cheatinfo->output); linenum++)
cheatinfo->output[linenum].reset();

10
src/emu/crsshair.c
View File

@ -196,8 +196,8 @@ static void create_bitmap(running_machine *machine, int player)
}
/* 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);
global.texture[player] = machine->render().texture_alloc(render_texture::hq_scale);
global.texture[player]->set_bitmap(global.bitmap[player], NULL, TEXFORMAT_ARGB32);
}
@ -263,8 +263,7 @@ static void crosshair_exit(running_machine &machine)
/* 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]);
machine.render().texture_free(global.texture[player]);
global.texture[player] = NULL;
global_free(global.bitmap[player]);
@ -396,8 +395,7 @@ void crosshair_render(screen_device &screen)
((global.screen[player] == &screen) || (global.screen[player] == CROSSHAIR_SCREEN_ALL)))
{
/* add a quad assuming a 4:3 screen (this is not perfect) */
render_screen_add_quad(&screen,
global.x[player] - 0.03f, global.y[player] - 0.04f,
screen.container().add_quad(global.x[player] - 0.03f, global.y[player] - 0.04f,
global.x[player] + 0.03f, global.y[player] + 0.04f,
MAKE_ARGB(0xc0, global.fade, global.fade, global.fade),
global.texture[player], PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));

8
src/emu/debug/debugcmd.c
View File

@ -1114,7 +1114,7 @@ static void execute_comment(running_machine *machine, int ref, int params, const
/* Now try adding the comment */
cpu->debug()->comment_add(address, param[1], 0x00ff0000);
cpu->machine->m_debug_view->update_all(DVT_DISASSEMBLY);
cpu->machine->debug_view().update_all(DVT_DISASSEMBLY);
}
@ -1138,7 +1138,7 @@ static void execute_comment_del(running_machine *machine, int ref, int params, c
/* If it's a number, it must be an address */
/* The bankoff and cbn will be pulled from what's currently active */
cpu->debug()->comment_remove(address);
cpu->machine->m_debug_view->update_all(DVT_DISASSEMBLY);
cpu->machine->debug_view().update_all(DVT_DISASSEMBLY);
}
@ -2427,9 +2427,9 @@ static void execute_snap(running_machine *machine, int ref, int params, const ch
const char *filename = param[0];
int scrnum = (params > 1) ? atoi(param[1]) : 0;
device_t *screen = machine->m_devicelist.find(SCREEN, scrnum);
screen_device *screen = downcast<screen_device *>(machine->m_devicelist.find(SCREEN, scrnum));
if ((screen == NULL) || !render_is_live_screen(screen))
if ((screen == NULL) || !machine->render().is_live(*screen))
{
debug_console_printf(machine, "Invalid screen number '%d'\n", scrnum);
return;

10
src/emu/debug/debugcon.c
View File

@ -382,7 +382,7 @@ CMDERR debug_console_execute_command(running_machine *machine, const char *comma
/* update all views */
if (echo)
{
machine->m_debug_view->update_all();
machine->debug_view().update_all();
debugger_refresh_display(machine);
}
return result;
@ -481,7 +481,7 @@ void CLIB_DECL debug_console_printf(running_machine *machine, const char *format
text_buffer_print(console_textbuf, buffer);
/* force an update of any console views */
machine->m_debug_view->update_all(DVT_CONSOLE);
machine->debug_view().update_all(DVT_CONSOLE);
}
@ -499,7 +499,7 @@ void CLIB_DECL debug_console_vprintf(running_machine *machine, const char *forma
text_buffer_print(console_textbuf, buffer);
/* force an update of any console views */
machine->m_debug_view->update_all(DVT_CONSOLE);
machine->debug_view().update_all(DVT_CONSOLE);
}
@ -521,7 +521,7 @@ void CLIB_DECL debug_console_printf_wrap(running_machine *machine, int wrapcol,
text_buffer_print_wrap(console_textbuf, buffer, wrapcol);
/* force an update of any console views */
machine->m_debug_view->update_all(DVT_CONSOLE);
machine->debug_view().update_all(DVT_CONSOLE);
}
@ -547,7 +547,7 @@ void debug_errorlog_write_line(running_machine &machine, const char *line)
text_buffer_print(errorlog_textbuf, line);
/* force an update of any log views */
machine.m_debug_view->update_all(DVT_LOG);
machine.debug_view().update_all(DVT_LOG);
}

14
src/emu/debug/debugcpu.c
View File

@ -1813,8 +1813,8 @@ void device_debug::start_hook(attotime endtime)
// check for periodic updates
if (&m_device == global->visiblecpu && osd_ticks() > global->last_periodic_update_time + osd_ticks_per_second()/4)
{
m_device.machine->m_debug_view->update_all();
m_device.machine->m_debug_view->flush_osd_updates();
m_device.machine->debug_view().update_all();
m_device.machine->debug_view().flush_osd_updates();
global->last_periodic_update_time = osd_ticks();
}
@ -1949,8 +1949,8 @@ void device_debug::instruction_hook(offs_t curpc)
// update every 100 steps until we are within 200 of the end
else if ((m_flags & DEBUG_FLAG_STEPPING_OUT) == 0 && (m_stepsleft < 200 || m_stepsleft % 100 == 0))
{
m_device.machine->m_debug_view->update_all();
m_device.machine->m_debug_view->flush_osd_updates();
m_device.machine->debug_view().update_all();
m_device.machine->debug_view().flush_osd_updates();
debugger_refresh_display(m_device.machine);
}
}
@ -1998,7 +1998,7 @@ void device_debug::instruction_hook(offs_t curpc)
global->visiblecpu = &m_device;
// update all views
m_device.machine->m_debug_view->update_all();
m_device.machine->debug_view().update_all();
debugger_refresh_display(m_device.machine);
// wait for the debugger; during this time, disable sound output
@ -2006,7 +2006,7 @@ void device_debug::instruction_hook(offs_t curpc)
while (global->execution_state == EXECUTION_STATE_STOPPED)
{
// flush any pending updates before waiting again
m_device.machine->m_debug_view->flush_osd_updates();
m_device.machine->debug_view().flush_osd_updates();
// clear the memory modified flag and wait
global->memory_modified = false;
@ -2019,7 +2019,7 @@ void device_debug::instruction_hook(offs_t curpc)
// if something modified memory, update the screen
if (global->memory_modified)
{
m_device.machine->m_debug_view->update_all(DVT_DISASSEMBLY);
m_device.machine->debug_view().update_all(DVT_DISASSEMBLY);
debugger_refresh_display(m_device.machine);
}

65
src/emu/debugint/debugint.c
View File

@ -159,8 +159,8 @@ public:
{
this->target = target;
//dv->container = render_target_get_component_container(target, name, &pos);
this->container = render_debug_alloc(target);
this->view = machine->m_debug_view->alloc_view(type, dview_update, this);
this->container = target->debug_alloc();
this->view = machine->debug_view().alloc_view(type, dview_update, this);
this->type = type;
this->machine = machine;
this->state = flags | VIEW_STATE_NEEDS_UPDATE;
@ -185,8 +185,8 @@ public:
}
~DView()
{
render_debug_free(this->target, this->container);
machine->m_debug_view->free_view(*this->view);
this->target->debug_free(*this->container);
machine->debug_view().free_view(*this->view);
}
DView * next;
@ -295,7 +295,7 @@ static void set_focus_view(DView *dv)
focus_view = dv;
LIST_REMOVE(list, dv, DView);
LIST_ADD_FRONT(list, dv, DView);
render_debug_top(dv->target, dv->container);
dv->target->debug_top(*dv->container);
}
}
@ -364,7 +364,7 @@ static void dview_get_rect(DView *dv, int type, rectangle *rect)
static void dview_clear(DView *dv)
{
render_container_empty(dv->container);
dv->container->empty();
}
static void dview_draw_outlined_box(DView *dv, int rtype, int x, int y, int w, int h, rgb_t bg)
@ -381,7 +381,7 @@ static void dview_draw_box(DView *dv, int rtype, int x, int y, int w, int h, rgb
rectangle r;
dview_get_rect(dv, rtype, &r);
render_container_add_rect(dv->container, NX(dv, x + r.min_x), NY(dv, y + r.min_y),
dv->container->add_rect(NX(dv, x + r.min_x), NY(dv, y + r.min_y),
NX(dv, x + r.min_x + w), NY(dv, y + r.min_y + h), col,
PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
@ -391,14 +391,14 @@ static void dview_draw_char(DView *dv, int rtype, int x, int y, int h, rgb_t col
rectangle r;
dview_get_rect(dv, rtype, &r);
render_container_add_char(dv->container,
dv->container->add_char(
NX(dv, x + r.min_x),
NY(dv, y + r.min_y),
NY(dv, h),
debug_font_aspect,
//(float) rect_get_height(&dv->bounds) / (float) rect_get_width(&dv->bounds), //render_get_ui_aspect(),
col,
debug_font,
*debug_font,
ch);
}
@ -777,15 +777,15 @@ static void dview_draw(DView *dv)
static void dview_size_allocate(DView *dv)
{
debug_view_xy size, pos, col, vsize;
render_container_user_settings rcus;
render_container::user_settings rcus;
rectangle r;
render_container_get_user_settings(dv->container, &rcus);
rcus.xoffset = (float) dv->ofs_x / (float) dv->rt_width;
rcus.yoffset = (float) dv->ofs_y / (float) dv->rt_height;
rcus.xscale = 1.0; //(float) rect_get_width(&dv->bounds) / (float) dv->rt_width;
rcus.yscale = 1.0; //(float) rect_get_height(&dv->bounds) / (float) dv->rt_height;
render_container_set_user_settings(dv->container, &rcus);
dv->container->get_user_settings(rcus);
rcus.m_xoffset = (float) dv->ofs_x / (float) dv->rt_width;
rcus.m_yoffset = (float) dv->ofs_y / (float) dv->rt_height;
rcus.m_xscale = 1.0; //(float) rect_get_width(&dv->bounds) / (float) dv->rt_width;
rcus.m_yscale = 1.0; //(float) rect_get_height(&dv->bounds) / (float) dv->rt_height;
dv->container->set_user_settings(rcus);
//printf("%d %d %d %d\n", wpos.min_x, wpos.max_x, wpos.min_y, wpos.max_y);
pos = dv->view->visible_position();
@ -899,7 +899,7 @@ void debugint_init(running_machine *machine)
{
unicode_char ch;
int chw;
debug_font = render_font_alloc("ui.bdf"); //ui_get_font();
debug_font = render_font_alloc(*machine, "ui.bdf"); //ui_get_font();
debug_font_width = 0;
debug_font_height = 15;
@ -908,7 +908,7 @@ void debugint_init(running_machine *machine)
list = NULL;
focus_view = NULL;
debug_font_aspect = render_get_ui_aspect();
debug_font_aspect = machine->render().ui_aspect();
for (ch=0;ch<=127;ch++)
{
@ -930,14 +930,14 @@ static void set_view_by_name(render_target *target, const char *name)
for (i = 0; ; i++ )
{
s = render_target_get_view_name(target, i);
s = target->view_name(i);
if (s == NULL)
return;
//printf("%d %s\n", i, s);
if (strcmp(name, s) == 0)
{
render_target_set_view(target, i);
//printf("%d\n", render_target_get_view(target) );
target->set_view(i);
//printf("%d\n", target->view() );
return;
}
}
@ -977,11 +977,11 @@ static void on_disassembly_window_activate(DView *dv, const ui_menu_event *event
render_target *target;
const debug_view_source *source;
target = render_get_ui_target();
target = &dv->machine->render().ui_target();
ndv = dview_alloc(target, dv->machine, DVT_DISASSEMBLY, 0);
ndv->editor.active = TRUE;
ndv->editor.container = render_container_get_ui();
ndv->editor.container = &dv->machine->render().ui_container();
source = ndv->view->source();
dview_set_title(ndv, source->name());
set_focus_view(ndv);
@ -1010,7 +1010,7 @@ static void on_log_window_activate(DView *dv, const ui_menu_event *event)
DView *ndv;
render_target *target;
target = render_get_ui_target();
target = &dv->machine->render().ui_target();
ndv = dview_alloc(target, dv->machine, DVT_LOG, 0);
dview_set_title(ndv, "Log");
set_focus_view(ndv);
@ -1125,7 +1125,7 @@ static void render_editor(DView_edit *editor)
float width, maxwidth;
float x1, y1, x2, y2;
render_container_empty(editor->container);
editor->container->empty();
/* get the size of the text */
ui_draw_text_full(editor->container, editor->str, 0.0f, 0.0f, 1.0f, JUSTIFY_CENTER, WRAP_TRUNCATE,
DRAW_NONE, ARGB_WHITE, ARGB_BLACK, &width, NULL);
@ -1165,7 +1165,7 @@ static void CreateMainMenu(running_machine *machine)
if (menu != NULL)
ui_menu_free(menu);
menu = ui_menu_alloc(machine, render_container_get_ui(),NULL,NULL);
menu = ui_menu_alloc(machine, &machine->render().ui_container(),NULL,NULL);
switch (focus_view->type)
{
@ -1348,7 +1348,7 @@ static void handle_menus(running_machine *machine)
{
const ui_menu_event *event;
render_container_empty(render_container_get_ui());
machine->render().ui_container().empty();
ui_input_frame_update(*machine);
if (menu != NULL)
{
@ -1414,7 +1414,8 @@ static void dview_update_view(DView *dv)
INT32 old_rt_width = dv->rt_width;
INT32 old_rt_height = dv->rt_height;
render_target_get_bounds(dv->target, &dv->rt_width, &dv->rt_height, NULL);
dv->rt_width = dv->target->width();
dv->rt_height = dv->target->height();
if (dview_is_state(dv, VIEW_STATE_NEEDS_UPDATE) || dv->rt_width != old_rt_width || dv->rt_height != old_rt_height)
{
dview_size_allocate(dv);
@ -1446,24 +1447,24 @@ void debugint_wait_for_debugger(running_device *device, int firststop)
DView *dv;
render_target *target;
target = render_get_ui_target();
target = &device->machine->render().ui_target();
//set_view_by_name(target, "Debug");
dv = dview_alloc(target, device->machine, DVT_DISASSEMBLY, VIEW_STATE_FOLLOW_CPU);
dv->editor.active = TRUE;
dv->editor.container = render_container_get_ui();
dv->editor.container = &device->machine->render().ui_container();
dv = dview_alloc(target, device->machine, DVT_STATE, VIEW_STATE_FOLLOW_CPU);
dv = dview_alloc(target, device->machine, DVT_CONSOLE, VIEW_STATE_FOLLOW_CPU);
dview_set_title(dv, "Console");
dv->editor.active = TRUE;
dv->editor.container = render_container_get_ui();
dv->editor.container = &device->machine->render().ui_container();
set_focus_view(dv);
}
followers_set_cpu(device);
//ui_update_and_render(device->machine, render_container_get_ui());
//ui_update_and_render(device->machine, &device->machine->render().ui_container()());
update_views();
osd_update(device->machine, FALSE);
handle_menus(device->machine);

2
src/emu/drivers/empty.c
View File

@ -23,7 +23,7 @@
static MACHINE_START( empty )
{
/* force the UI to show the game select screen */
ui_menu_force_game_select(machine, render_container_get_ui());
ui_menu_force_game_select(machine, &machine->render().ui_container());
}

51
src/emu/emualloc.c
View File

@ -77,11 +77,11 @@ public:
void * m_base; // base of the allocation
const char * m_file; // file the allocation was made from
int m_line; // line number within that file
int m_id; // unique id
UINT64 m_id; // unique id
static const int k_hash_prime = 193;
static int s_curid; // current ID
static UINT64 s_curid; // current ID
static osd_lock * s_lock; // lock for managing the list
static bool s_lock_alloc; // set to true temporarily during lock allocation
static memory_entry *s_hash[k_hash_prime];// hash table based on pointer
@ -110,7 +110,7 @@ resource_pool global_resource_pool;
const zeromem_t zeromem = { };
// globals for memory_entry
int memory_entry::s_curid = 0;
UINT64 memory_entry::s_curid = 0;
osd_lock *memory_entry::s_lock = NULL;
bool memory_entry::s_lock_alloc = false;
memory_entry *memory_entry::s_hash[memory_entry::k_hash_prime] = { NULL };
@ -134,10 +134,10 @@ void *malloc_file_line(size_t size, const char *file, int line)
if (result == NULL)
return NULL;
#ifdef MAME_DEBUG
// add a new entry
memory_entry::allocate(size, result, file, line);
#ifdef MAME_DEBUG
// randomize the memory
rand_memory(result, size);
#endif
@ -153,7 +153,6 @@ void *malloc_file_line(size_t size, const char *file, int line)
void free_file_line(void *memory, const char *file, int line)
{
#ifdef MAME_DEBUG
// find the memory entry
memory_entry *entry = memory_entry::find(memory);
@ -165,6 +164,7 @@ void free_file_line(void *memory, const char *file, int line)
return;
}
#ifdef MAME_DEBUG
// clear memory to a bogus value
memset(memory, 0xfc, entry->m_size);
@ -237,14 +237,41 @@ void resource_pool::add(resource_pool_item &item)
item.m_next = m_hash[hashval];
m_hash[hashval] = &item;
// insert into ordered list
item.m_ordered_next = NULL;
item.m_ordered_prev = m_ordered_tail;
if (m_ordered_tail != NULL)
m_ordered_tail->m_ordered_next = &item;
// fetch the ID of this item's pointer; some implementations put hidden data
// before, so if we don't find it, check 4 bytes ahead
memory_entry *entry = memory_entry::find(item.m_ptr);
if (entry == NULL)
entry = memory_entry::find(reinterpret_cast<UINT8 *>(item.m_ptr) - sizeof(size_t));
assert(entry != NULL);
item.m_id = entry->m_id;
// find the entry to insert after
resource_pool_item *insert_after;
for (insert_after = m_ordered_tail; insert_after != NULL; insert_after = insert_after->m_ordered_prev)
if (insert_after->m_id < item.m_id)
break;
// insert into the appropriate spot
if (insert_after != NULL)
{
item.m_ordered_next = insert_after->m_ordered_next;
if (item.m_ordered_next != NULL)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
if (m_ordered_head == NULL)
item.m_ordered_prev = insert_after;
insert_after->m_ordered_next = &item;
}
else
{
item.m_ordered_next = m_ordered_head;
if (item.m_ordered_next != NULL)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = NULL;
m_ordered_head = &item;
}
osd_lock_release(m_listlock);
}
@ -516,7 +543,7 @@ void memory_entry::report_unfreed()
if (total == 0)
fprintf(stderr, "--- memory leak warning ---\n");
total += entry->m_size;
fprintf(stderr, "allocation #%06d, %d bytes (%s:%d)\n", entry->m_id, static_cast<UINT32>(entry->m_size), entry->m_file, (int)entry->m_line);
fprintf(stderr, "allocation #%06d, %d bytes (%s:%d)\n", (UINT32)entry->m_id, static_cast<UINT32>(entry->m_size), entry->m_file, (int)entry->m_line);
}
release_lock();

4
src/emu/emualloc.h
View File

@ -87,7 +87,8 @@ public:
m_ordered_next(NULL),
m_ordered_prev(NULL),
m_ptr(ptr),
m_size(size) { }
m_size(size),
m_id(~(UINT64)0) { }
virtual ~resource_pool_item() { }
resource_pool_item * m_next;
@ -95,6 +96,7 @@ public:
resource_pool_item * m_ordered_prev;
void * m_ptr;
size_t m_size;
UINT64 m_id;
};

108
src/emu/emucore.h
View File

@ -381,17 +381,6 @@ public:
void reset() { while (m_head != NULL) remove(*m_head); }
int index(T *object) const
{
int num = 0;
for (T *cur = m_head; cur != NULL; cur = cur->m_next)
if (cur == object)
return num;
else
num++;
return -1;
}
T &prepend(T &object)
{
object.m_next = m_head;
@ -402,6 +391,20 @@ public:
return object;
}
void prepend_list(simple_list<T> &list)
{
int count = list.count();
if (count == 0)
return;
T *tail = list.last();
T *head = list.detach_all();
tail->m_next = m_head;
m_head = head;
if (m_tail == NULL)
m_tail = tail;
m_count += count;
}
T &append(T &object)
{
object.m_next = NULL;
@ -413,7 +416,35 @@ public:
return object;
}
void detach(T &object)
void append_list(simple_list<T> &list)
{
int count = list.count();
if (count == 0)
return;
T *tail = list.last();
T *head = list.detach_all();
if (m_tail != NULL)
m_tail->m_next = head;
else
m_head = head;
m_tail = tail;
m_count += count;
}
T *detach_head()
{
T *result = m_head;
if (result != NULL)
{
m_head = result->m_next;
m_count--;
if (m_head == NULL)
m_tail = NULL;
}
return result;
}
T &detach(T &object)
{
T *prev = NULL;
for (T *cur = m_head; cur != NULL; prev = cur, cur = cur->m_next)
@ -426,8 +457,17 @@ public:
if (m_tail == &object)
m_tail = prev;
m_count--;
return;
return object;
}
return object;
}
T *detach_all()
{
T *result = m_head;
m_head = m_tail = NULL;
m_count = 0;
return result;
}
void remove(T &object)
@ -443,6 +483,48 @@ public:
return cur;
return NULL;
}
int indexof(const T &object) const
{
int index = 0;
for (T *cur = m_head; cur != NULL; cur = cur->m_next)
{
if (cur == &object)
return index;
index++;
}
return -1;
}
};
// ======================> fixed_allocator
template<class T>
class fixed_allocator
{
DISABLE_COPYING(fixed_allocator);
public:
fixed_allocator(resource_pool &pool = global_resource_pool)
: m_pool(pool),
m_freelist(pool) { }
T *alloc()
{
T *result = m_freelist.detach_head();
if (result == NULL)
result = m_pool.add_object(new T);
return result;
}
void reclaim(T *item) { if (item != NULL) m_freelist.append(*item); }
void reclaim(T &item) { m_freelist.append(item); }
void reclaim_all(simple_list<T> &list) { m_freelist.append_list(list); }
private:
resource_pool &m_pool;
simple_list<T> m_freelist;
};

3
src/emu/inptport.c
View File

@ -2490,7 +2490,8 @@ g_profiler.start(PROFILER_INPUT);
{
const char *tag = NULL;
input_port_value mask;
if (render_target_map_point_input(mouse_target, mouse_target_x, mouse_target_y, &tag, &mask, NULL, NULL))
float x, y;
if (mouse_target->map_point_input(mouse_target_x, mouse_target_y, tag, mask, x, y))
mouse_field = input_field_by_tag_and_mask(machine->m_portlist, tag, mask);
}

9
src/emu/machine.c
View File

@ -173,7 +173,6 @@ running_machine::running_machine(const machine_config &_config, core_options &op
generic_machine_data(NULL),
generic_video_data(NULL),
generic_audio_data(NULL),
m_debug_view(NULL),
m_logerror_list(NULL),
m_scheduler(*this),
m_options(options),
@ -190,7 +189,9 @@ running_machine::running_machine(const machine_config &_config, core_options &op
m_saveload_schedule_time(attotime_zero),
m_saveload_searchpath(NULL),
m_rand_seed(0x9d14abd7),
m_driver_device(NULL)
m_driver_device(NULL),
m_render(NULL),
m_debug_view(NULL)
{
memset(gfx, 0, sizeof(gfx));
memset(&generic, 0, sizeof(generic));
@ -271,7 +272,7 @@ void running_machine::start()
state_init(this);
state_save_allow_registration(this, true);
palette_init(this);
render_init(this);
m_render = auto_alloc(this, render_manager(*this));
ui_init(this);
generic_machine_init(this);
generic_video_init(this);
@ -453,7 +454,7 @@ void running_machine::schedule_exit()
if (m_exit_to_game_select && options_get_string(&m_options, OPTION_GAMENAME)[0] != 0)
{
options_set_string(&m_options, OPTION_GAMENAME, "", OPTION_PRIORITY_CMDLINE);
ui_menu_force_game_select(this, render_container_get_ui());
ui_menu_force_game_select(this, &render().ui_container());
}
// otherwise, exit for real

11
src/emu/machine.h
View File

@ -181,6 +181,7 @@ const int DEBUG_FLAG_OSD_ENABLED = 0x00001000; // The OSD debugger is enabled
class gfx_element;
class colortable_t;
class debug_view_manager;
class render_manager;
typedef struct _mame_private mame_private;
typedef struct _cpuexec_private cpuexec_private;
@ -329,6 +330,8 @@ class running_machine : public bindable_object
{
DISABLE_COPYING(running_machine);
friend void debugger_init(running_machine *machine);
typedef void (*notify_callback)(running_machine &machine);
typedef void (*logerror_callback)(running_machine &machine, const char *string);
@ -382,6 +385,10 @@ public:
region_info *region_alloc(const char *name, UINT32 length, UINT32 flags);
void region_free(const char *name);
// managers
render_manager &render() const { assert(m_render != NULL); return *m_render; }
debug_view_manager &debug_view() const { assert(m_debug_view != NULL); return *m_debug_view; }
// misc
void CLIB_DECL logerror(const char *format, ...);
void CLIB_DECL vlogerror(const char *format, va_list args);
@ -449,8 +456,6 @@ public:
generic_video_private * generic_video_data; // internal data from video/generic.c
generic_audio_private * generic_audio_data; // internal data from audio/generic.c
debug_view_manager * m_debug_view; // internal data from debugvw.c
// driver-specific information
driver_device *driver_data() const { return m_driver_device; }
@ -520,6 +525,8 @@ private:
time_t m_base_time;
driver_device * m_driver_device;
render_manager * m_render; // internal data from render.c
debug_view_manager * m_debug_view; // internal data from debugvw.c
};

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

@ -1246,22 +1246,22 @@ VIDEO_UPDATE( laserdisc )
if (overbitmap != NULL)
{
if (overbitmap->format == BITMAP_FORMAT_INDEXED16)
render_texture_set_bitmap(ldcore->overtex, overbitmap, &ldcore->config.overclip, TEXFORMAT_PALETTEA16, laserdisc->machine->palette);
ldcore->overtex->set_bitmap(overbitmap, &ldcore->config.overclip, TEXFORMAT_PALETTEA16, laserdisc->machine->palette);
else if (overbitmap->format == BITMAP_FORMAT_RGB32)
render_texture_set_bitmap(ldcore->overtex, overbitmap, &ldcore->config.overclip, TEXFORMAT_ARGB32, NULL);
ldcore->overtex->set_bitmap(overbitmap, &ldcore->config.overclip, TEXFORMAT_ARGB32);
}
/* get the laserdisc video */
laserdisc_get_video(laserdisc, &vidbitmap);
if (vidbitmap != NULL)
render_texture_set_bitmap(ldcore->videotex, vidbitmap, NULL, TEXFORMAT_YUY16, ldcore->videopalette);
ldcore->videotex->set_bitmap(vidbitmap, NULL, TEXFORMAT_YUY16, ldcore->videopalette);
/* reset the screen contents */
render_container_empty(render_container_get_screen(screen));
screen->container().empty();
/* add the video texture */
if (ldcore->videoenable)
render_screen_add_quad(screen, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), ldcore->videotex, PRIMFLAG_BLENDMODE(BLENDMODE_NONE) | PRIMFLAG_SCREENTEX(1));
screen->container().add_quad(0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), ldcore->videotex, PRIMFLAG_BLENDMODE(BLENDMODE_NONE) | PRIMFLAG_SCREENTEX(1));
/* add the overlay */
if (ldcore->overenable && overbitmap != NULL)
@ -1270,7 +1270,7 @@ VIDEO_UPDATE( laserdisc )
float y0 = 0.5f - 0.5f * ldcore->config.overscaley + ldcore->config.overposy;
float x1 = x0 + ldcore->config.overscalex;
float y1 = y0 + ldcore->config.overscaley;
render_screen_add_quad(screen, x0, y0, x1, y1, MAKE_ARGB(0xff,0xff,0xff,0xff), ldcore->overtex, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_SCREENTEX(1));
screen->container().add_quad(x0, y0, x1, y1, MAKE_ARGB(0xff,0xff,0xff,0xff), ldcore->overtex, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_SCREENTEX(1));
}
/* swap to the next bitmap */
@ -1418,7 +1418,7 @@ static void init_video(running_device *device)
/* allocate texture for rendering */
ldcore->videoenable = TRUE;
ldcore->videotex = render_texture_alloc(NULL, NULL);
ldcore->videotex = device->machine->render().texture_alloc();
if (ldcore->videotex == NULL)
fatalerror("Out of memory allocating video texture");
@ -1435,7 +1435,7 @@ static void init_video(running_device *device)
ldcore->overenable = TRUE;
ldcore->overbitmap[0] = auto_bitmap_alloc(device->machine, ldcore->config.overwidth, ldcore->config.overheight, (bitmap_format)ldcore->config.overformat);
ldcore->overbitmap[1] = auto_bitmap_alloc(device->machine, ldcore->config.overwidth, ldcore->config.overheight, (bitmap_format)ldcore->config.overformat);
ldcore->overtex = render_texture_alloc(NULL, NULL);
ldcore->overtex = device->machine->render().texture_alloc();
if (ldcore->overtex == NULL)
fatalerror("Out of memory allocating overlay texture");
}
@ -1536,12 +1536,10 @@ static DEVICE_STOP( laserdisc )
chd_async_complete(ldcore->disc);
/* free any textures and palettes */
if (ldcore->videotex != NULL)
render_texture_free(ldcore->videotex);
device->machine->render().texture_free(ldcore->videotex);
if (ldcore->videopalette != NULL)
palette_deref(ldcore->videopalette);
if (ldcore->overtex != NULL)
render_texture_free(ldcore->overtex);
device->machine->render().texture_free(ldcore->overtex);
}

5191
src/emu/render.c
View File

File diff suppressed because it is too large Load Diff

872
src/emu/render.h
View File

@ -4,21 +4,38 @@
Core rendering routines for MAME.
Copyright Nicola Salmoria and the MAME Team.
Visit http://mamedev.org for licensing and usage restrictions.
****************************************************************************
***************************************************************************/
Copyright Aaron Giles
All rights reserved.
#ifndef __RENDER_H__
#define __RENDER_H__
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
#include "osdepend.h"
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name 'MAME' nor the names of its contributors may be
used to endorse or promote products derived from this software
without specific prior written permission.
#include <math.h>
THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
/***************************************************************************
****************************************************************************
Theory of operation
-------------------
@ -55,414 +72,631 @@
***************************************************************************/
#ifndef __RENDER_H__
#define __RENDER_H__
/***************************************************************************
CONSTANTS
***************************************************************************/
#include "osdepend.h"
/* render primitive types */
#include <math.h>
//**************************************************************************
// CONSTANTS
//**************************************************************************
// texture formats
enum
{
RENDER_PRIMITIVE_LINE, /* a single line */
RENDER_PRIMITIVE_QUAD /* a rectilinear quad */
TEXFORMAT_UNDEFINED = 0, // require a format to be specified
TEXFORMAT_PALETTE16, // 16bpp palettized, alpha ignored
TEXFORMAT_PALETTEA16, // 16bpp palettized, alpha respected
TEXFORMAT_RGB15, // 16bpp 5-5-5 RGB
TEXFORMAT_RGB32, // 32bpp 8-8-8 RGB
TEXFORMAT_ARGB32, // 32bpp 8-8-8-8 ARGB
TEXFORMAT_YUY16 // 16bpp 8-8 Y/Cb, Y/Cr in sequence
};
// blending modes
enum
{
BLENDMODE_NONE = 0, // no blending
BLENDMODE_ALPHA, // standard alpha blend
BLENDMODE_RGB_MULTIPLY, // apply source alpha to source pix, then multiply RGB values
BLENDMODE_ADD // apply source alpha to source pix, then add to destination
};
/* render creation flags */
#define RENDER_CREATE_NO_ART 0x01 /* ignore any views that have art in them */
#define RENDER_CREATE_SINGLE_FILE 0x02 /* only load views from the file specified */
#define RENDER_CREATE_HIDDEN 0x04 /* don't make this target visible */
/* layer config masks */
#define LAYER_CONFIG_ENABLE_BACKDROP 0x01 /* enable backdrop layers */
#define LAYER_CONFIG_ENABLE_OVERLAY 0x02 /* enable overlay layers */
#define LAYER_CONFIG_ENABLE_BEZEL 0x04 /* enable bezel layers */
#define LAYER_CONFIG_ZOOM_TO_SCREEN 0x08 /* zoom to screen area by default */
#define LAYER_CONFIG_ENABLE_SCREEN_OVERLAY 0x10 /* enable screen overlays */
#define LAYER_CONFIG_DEFAULT (LAYER_CONFIG_ENABLE_BACKDROP | \
LAYER_CONFIG_ENABLE_OVERLAY | \
LAYER_CONFIG_ENABLE_BEZEL | \
LAYER_CONFIG_ENABLE_SCREEN_OVERLAY)
/* texture formats */
enum
{
TEXFORMAT_UNDEFINED = 0, /* require a format to be specified */
TEXFORMAT_PALETTE16, /* 16bpp palettized, alpha ignored */
TEXFORMAT_PALETTEA16, /* 16bpp palettized, alpha respected */
TEXFORMAT_RGB15, /* 16bpp 5-5-5 RGB */
TEXFORMAT_RGB32, /* 32bpp 8-8-8 RGB */
TEXFORMAT_ARGB32, /* 32bpp 8-8-8-8 ARGB */
TEXFORMAT_YUY16 /* 16bpp 8-8 Y/Cb, Y/Cr in sequence */
};
/* blending modes */
enum
{
BLENDMODE_NONE = 0, /* no blending */
BLENDMODE_ALPHA, /* standard alpha blend */
BLENDMODE_RGB_MULTIPLY, /* apply source alpha to source pix, then multiply RGB values */
BLENDMODE_ADD /* apply source alpha to source pix, then add to destination */
};
// render creation flags
const UINT8 RENDER_CREATE_NO_ART = 0x01; // ignore any views that have art in them
const UINT8 RENDER_CREATE_SINGLE_FILE = 0x02; // only load views from the file specified
const UINT8 RENDER_CREATE_HIDDEN = 0x04; // don't make this target visible
/* flags for primitives */
#define PRIMFLAG_TEXORIENT_SHIFT 0
#define PRIMFLAG_TEXORIENT_MASK (15 << PRIMFLAG_TEXORIENT_SHIFT)
// layer config masks
const UINT8 LAYER_CONFIG_ENABLE_BACKDROP = 0x01; // enable backdrop layers
const UINT8 LAYER_CONFIG_ENABLE_OVERLAY = 0x02; // enable overlay layers
const UINT8 LAYER_CONFIG_ENABLE_BEZEL = 0x04; // enable bezel layers
const UINT8 LAYER_CONFIG_ZOOM_TO_SCREEN = 0x08; // zoom to screen area by default
const UINT8 LAYER_CONFIG_ENABLE_SCREEN_OVERLAY = 0x10; // enable screen overlays
const UINT8 LAYER_CONFIG_DEFAULT = (LAYER_CONFIG_ENABLE_BACKDROP |
LAYER_CONFIG_ENABLE_OVERLAY |
LAYER_CONFIG_ENABLE_BEZEL |
LAYER_CONFIG_ENABLE_SCREEN_OVERLAY);
// flags for primitives
const int PRIMFLAG_TEXORIENT_SHIFT = 0;
const UINT32 PRIMFLAG_TEXORIENT_MASK = 15 << PRIMFLAG_TEXORIENT_SHIFT;
const int PRIMFLAG_TEXFORMAT_SHIFT = 4;
const UINT32 PRIMFLAG_TEXFORMAT_MASK = 15 << PRIMFLAG_TEXFORMAT_SHIFT;
const int PRIMFLAG_BLENDMODE_SHIFT = 8;
const UINT32 PRIMFLAG_BLENDMODE_MASK = 15 << PRIMFLAG_BLENDMODE_SHIFT;
const int PRIMFLAG_ANTIALIAS_SHIFT = 12;
const UINT32 PRIMFLAG_ANTIALIAS_MASK = 1 << PRIMFLAG_ANTIALIAS_SHIFT;
const int PRIMFLAG_SCREENTEX_SHIFT = 13;
const UINT32 PRIMFLAG_SCREENTEX_MASK = 1 << PRIMFLAG_SCREENTEX_SHIFT;
const int PRIMFLAG_TEXWRAP_SHIFT = 14;
const UINT32 PRIMFLAG_TEXWRAP_MASK = 1 << PRIMFLAG_TEXWRAP_SHIFT;
//**************************************************************************
// MACROS
//**************************************************************************
#define PRIMFLAG_TEXORIENT(x) ((x) << PRIMFLAG_TEXORIENT_SHIFT)
#define PRIMFLAG_GET_TEXORIENT(x) (((x) & PRIMFLAG_TEXORIENT_MASK) >> PRIMFLAG_TEXORIENT_SHIFT)
#define PRIMFLAG_TEXFORMAT_SHIFT 4
#define PRIMFLAG_TEXFORMAT_MASK (15 << PRIMFLAG_TEXFORMAT_SHIFT)
#define PRIMFLAG_TEXFORMAT(x) ((x) << PRIMFLAG_TEXFORMAT_SHIFT)
#define PRIMFLAG_GET_TEXFORMAT(x) (((x) & PRIMFLAG_TEXFORMAT_MASK) >> PRIMFLAG_TEXFORMAT_SHIFT)
#define PRIMFLAG_BLENDMODE_SHIFT 8
#define PRIMFLAG_BLENDMODE_MASK (15 << PRIMFLAG_BLENDMODE_SHIFT)
#define PRIMFLAG_BLENDMODE(x) ((x) << PRIMFLAG_BLENDMODE_SHIFT)
#define PRIMFLAG_GET_BLENDMODE(x) (((x) & PRIMFLAG_BLENDMODE_MASK) >> PRIMFLAG_BLENDMODE_SHIFT)
#define PRIMFLAG_ANTIALIAS_SHIFT 12
#define PRIMFLAG_ANTIALIAS_MASK (1 << PRIMFLAG_ANTIALIAS_SHIFT)
#define PRIMFLAG_ANTIALIAS(x) ((x) << PRIMFLAG_ANTIALIAS_SHIFT)
#define PRIMFLAG_GET_ANTIALIAS(x) (((x) & PRIMFLAG_ANTIALIAS_MASK) >> PRIMFLAG_ANTIALIAS_SHIFT)
#define PRIMFLAG_SCREENTEX_SHIFT 13
#define PRIMFLAG_SCREENTEX_MASK (1 << PRIMFLAG_SCREENTEX_SHIFT)
#define PRIMFLAG_SCREENTEX(x) ((x) << PRIMFLAG_SCREENTEX_SHIFT)
#define PRIMFLAG_GET_SCREENTEX(x) (((x) & PRIMFLAG_SCREENTEX_MASK) >> PRIMFLAG_SCREENTEX_SHIFT)
#define PRIMFLAG_TEXWRAP_SHIFT 14
#define PRIMFLAG_TEXWRAP_MASK (1 << PRIMFLAG_TEXWRAP_SHIFT)
#define PRIMFLAG_TEXWRAP(x) ((x) << PRIMFLAG_TEXWRAP_SHIFT)
#define PRIMFLAG_GET_TEXWRAP(x) (((x) & PRIMFLAG_TEXWRAP_MASK) >> PRIMFLAG_TEXWRAP_SHIFT)
/***************************************************************************
MACROS
***************************************************************************/
/* convenience macros for adding items to the UI container */
#define render_container_add_point(c, x0,y0,diam,argb,flags) render_container_add_line(c, x0, y0, x0, y0, diam, argb, flags)
#define render_container_add_rect(c, x0,y0,x1,y1,argb,flags) render_container_add_quad(c, x0, y0, x1, y1, argb, NULL, flags)
/* convenience macros for adding items to a screen container */
#define render_screen_add_point(scr,x0,y0,diam,argb,flags) render_container_add_line(render_container_get_screen(scr), x0, y0, x0, y0, diam, argb, flags)
#define render_screen_add_line(scr,x0,y0,x1,y1,diam,argb,flags) render_container_add_line(render_container_get_screen(scr), x0, y0, x1, y1, diam, argb, flags)
#define render_screen_add_rect(scr,x0,y0,x1,y1,argb,flags) render_container_add_quad(render_container_get_screen(scr), x0, y0, x1, y1, argb, NULL, flags)
#define render_screen_add_quad(scr,x0,y0,x1,y1,argb,tex,flags) render_container_add_quad(render_container_get_screen(scr), x0, y0, x1, y1, argb, tex, flags)
#define render_screen_add_char(scr,x0,y0,ht,asp,argb,font,ch) render_container_add_char(render_container_get_screen(scr), x0, y0, ht, asp, argb, font, ch)
/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
//**************************************************************************
// TYPE DEFINITIONS
//**************************************************************************
// forward definitions
class device_t;
class device_config;
class screen_device;
/*-------------------------------------------------
callbacks
-------------------------------------------------*/
/* texture scaling callback */
typedef void (*texture_scaler_func)(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param);
/*-------------------------------------------------
opaque types
-------------------------------------------------*/
typedef struct _render_container render_container;
class render_target;
struct render_texture;
class render_container;
class render_manager;
typedef struct _xml_data_node xml_data_node;
typedef struct _render_font render_font;
typedef struct _render_ref render_ref;
struct object_transform;
typedef struct _layout_element layout_element;
typedef struct _layout_view layout_view;
typedef struct _view_item view_item;
typedef struct _layout_file layout_file;
// texture scaling callback
typedef void (*texture_scaler_func)(bitmap_t &dest, const bitmap_t &source, const rectangle &sbounds, void *param);
/*-------------------------------------------------
render_bounds - floating point bounding
rectangle
-------------------------------------------------*/
typedef struct _render_bounds render_bounds;
struct _render_bounds
// render_bounds - floating point bounding rectangle
struct render_bounds
{
float x0; /* leftmost X coordinate */
float y0; /* topmost Y coordinate */
float x1; /* rightmost X coordinate */
float y1; /* bottommost Y coordinate */
float x0; // leftmost X coordinate
float y0; // topmost Y coordinate
float x1; // rightmost X coordinate
float y1; // bottommost Y coordinate
};
/*-------------------------------------------------
render_color - floating point set of ARGB
values
-------------------------------------------------*/
typedef struct _render_color render_color;
struct _render_color
// render_color - floating point set of ARGB values
struct render_color
{
float a; /* alpha component (0.0 = transparent, 1.0 = opaque) */
float r; /* red component (0.0 = none, 1.0 = max) */
float g; /* green component (0.0 = none, 1.0 = max) */
float b; /* blue component (0.0 = none, 1.0 = max) */
float a; // alpha component (0.0 = transparent, 1.0 = opaque)
float r; // red component (0.0 = none, 1.0 = max)
float g; // green component (0.0 = none, 1.0 = max)
float b; // blue component (0.0 = none, 1.0 = max)
};
/*-------------------------------------------------
render_texuv - floating point set of UV
texture coordinates
-------------------------------------------------*/
typedef struct _render_texuv render_texuv;
struct _render_texuv
// render_texuv - floating point set of UV texture coordinates
struct render_texuv
{
float u; /* U coodinate (0.0-1.0) */
float v; /* V coordinate (0.0-1.0) */
float u; // U coodinate (0.0-1.0)
float v; // V coordinate (0.0-1.0)
};
/*-------------------------------------------------
render_quad_texuv - floating point set of UV
texture coordinates
-------------------------------------------------*/
typedef struct _render_quad_texuv render_quad_texuv;
struct _render_quad_texuv
// render_quad_texuv - floating point set of UV texture coordinates
struct render_quad_texuv
{
render_texuv tl; /* top-left UV coordinate */
render_texuv tr; /* top-right UV coordinate */
render_texuv bl; /* bottom-left UV coordinate */
render_texuv br; /* bottom-right UV coordinate */
render_texuv tl; // top-left UV coordinate
render_texuv tr; // top-right UV coordinate
render_texuv bl; // bottom-left UV coordinate
render_texuv br; // bottom-right UV coordinate
};
/*-------------------------------------------------
render_texinfo - texture information
-------------------------------------------------*/
typedef struct _render_texinfo render_texinfo;
struct _render_texinfo
// render_texinfo - texture information
struct render_texinfo
{
void * base; /* base of the data */
UINT32 rowpixels; /* pixels per row */
UINT32 width; /* width of the image */
UINT32 height; /* height of the image */
const rgb_t * palette; /* palette for PALETTE16 textures, LUTs for RGB15/RGB32 */
UINT32 seqid; /* sequence ID */
void * base; // base of the data
UINT32 rowpixels; // pixels per row
UINT32 width; // width of the image
UINT32 height; // height of the image
const rgb_t * palette; // palette for PALETTE16 textures, LUTs for RGB15/RGB32
UINT32 seqid; // sequence ID
};
/*-------------------------------------------------
render_primitive - a single low-level
primitive for the rendering engine
-------------------------------------------------*/
// ======================> render_primitive
typedef struct _render_primitive render_primitive;
struct _render_primitive
// render_primitive - a single low-level primitive for the rendering engine
class render_primitive
{
render_primitive * next; /* pointer to next element */
int type; /* type of primitive */
render_bounds bounds; /* bounds or positions */
render_color color; /* RGBA values */
UINT32 flags; /* flags */
float width; /* width (for line primitives) */
render_texinfo texture; /* texture info (for quad primitives) */
render_quad_texuv texcoords; /* texture coordinates (for quad primitives) */
friend class simple_list<render_primitive>;
public:
// render primitive types
enum primitive_type
{
INVALID = 0, // invalid type
LINE, // a single line
QUAD // a rectilinear quad
};
// getters
render_primitive *next() const { return m_next; }
// reset to prepare for re-use
void reset();
// public state
primitive_type type; // type of primitive
render_bounds bounds; // bounds or positions
render_color color; // RGBA values
UINT32 flags; // flags
float width; // width (for line primitives)
render_texinfo texture; // texture info (for quad primitives)
render_quad_texuv texcoords; // texture coordinates (for quad primitives)
private:
// internal state
render_primitive * m_next; // pointer to next element
};
/*-------------------------------------------------
render_primitive_list - an object containing
a list head plus a lock
-------------------------------------------------*/
// ======================> render_primitive_list
typedef struct _render_primitive_list render_primitive_list;
struct _render_primitive_list
// render_primitive_list - an object containing a list head plus a lock
class render_primitive_list
{
render_primitive * head; /* head of the list */
render_primitive ** nextptr; /* pointer to the next tail pointer */
osd_lock * lock; /* should only should be accessed under this lock */
render_ref * reflist; /* list of references */
friend class render_target;
// construction/destruction
render_primitive_list();
~render_primitive_list();
public:
// getters
render_primitive *first() const { return m_primlist.first(); }
// lock management
void acquire_lock() { osd_lock_acquire(m_lock); }
void release_lock() { osd_lock_release(m_lock); }
// reference management
void add_reference(void *refptr);
bool has_reference(void *refptr) const;
private:
// helpers for our friends to manipulate the list
render_primitive *alloc(render_primitive::primitive_type type);
void release_all();
void append(render_primitive &prim) { append_or_return(prim, false); }
void append_or_return(render_primitive &prim, bool clipped);
// a reference is an abstract reference to an internal object of some sort
class reference
{
public:
reference *next() const { return m_next; }
reference * m_next; // link to the next reference
void * m_refptr; // reference pointer
};
// internal state
simple_list<render_primitive> m_primlist; // list of primitives
simple_list<reference> m_reflist; // list of references
fixed_allocator<render_primitive> m_primitive_allocator;// allocator for primitives
fixed_allocator<reference> m_reference_allocator; // allocator for references
osd_lock * m_lock; // lock to protect list accesses
};
/*-------------------------------------------------
render_container_user_settings - an object
containing user-controllable settings for
a container
-------------------------------------------------*/
// ======================> render_texture
typedef struct _render_container_user_settings render_container_user_settings;
struct _render_container_user_settings
// a render_texture is used to track transformations when building an object list
class render_texture
{
int orientation; /* orientation */
float brightness; /* brightness */
float contrast; /* contrast */
float gamma; /* gamma */
float xscale; /* horizontal scale factor */
float yscale; /* vertical scale factor */
float xoffset; /* horizontal offset */
float yoffset; /* vertical offset */
friend resource_pool_object<render_texture>::~resource_pool_object();
friend class simple_list<render_texture>;
friend class fixed_allocator<render_texture>;
friend class render_manager;
friend class render_target;
// construction/destruction
render_texture();
~render_texture();
// reset before re-use
void reset(render_manager &manager, texture_scaler_func scaler = NULL, void *param = NULL);
public:
// getters
int format() const { return m_format; }
// configure the texture bitmap
void set_bitmap(bitmap_t *bitmap, const rectangle *sbounds, int format, palette_t *palette = NULL);
// generic high-quality bitmap scaler
static void hq_scale(bitmap_t &dest, const bitmap_t &source, const rectangle &sbounds, void *param);
private:
// internal helpers
bool get_scaled(UINT32 dwidth, UINT32 dheight, render_texinfo &texinfo, render_primitive_list &primlist);
const rgb_t *get_adjusted_palette(render_container &container);
static const int MAX_TEXTURE_SCALES = 8;
// a scaled_texture contains a single scaled entry for a texture
struct scaled_texture
{
bitmap_t * bitmap; // final bitmap
UINT32 seqid; // sequence number
};
// internal state
render_manager * m_manager; // reference to our manager
render_texture * m_next; // next texture (for free list)
bitmap_t * m_bitmap; // pointer to the original bitmap
rectangle m_sbounds; // source bounds within the bitmap
palette_t * m_palette; // palette associated with the texture
int m_format; // format of the texture data
texture_scaler_func m_scaler; // scaling callback
void * m_param; // scaling callback parameter
UINT32 m_curseq; // current sequence number
scaled_texture m_scaled[MAX_TEXTURE_SCALES];// array of scaled variants of this texture
rgb_t * m_bcglookup; // dynamically allocated B/C/G lookup table
UINT32 m_bcglookup_entries; // number of B/C/G lookup entries allocated
};
// ======================> render_container
/***************************************************************************
FUNCTION PROTOTYPES
***************************************************************************/
// a render_container holds a list of items and an orientation for the entire collection
class render_container
{
friend resource_pool_object<render_container>::~resource_pool_object();
friend class simple_list<render_container>;
friend class render_manager;
friend class render_target;
// construction/destruction
render_container(render_manager &manager, screen_device *screen = NULL);
~render_container();
public:
// user settings describes the collected user-controllable settings
struct user_settings
{
// construction/destruction
user_settings();
// public state
int m_orientation; // orientation
float m_brightness; // brightness
float m_contrast; // contrast
float m_gamma; // gamma
float m_xscale; // horizontal scale factor
float m_yscale; // vertical scale factor
float m_xoffset; // horizontal offset
float m_yoffset; // vertical offset
};
// getters
render_container *next() const { return m_next; }
screen_device *screen() const { return m_screen; }
render_manager &manager() const { return m_manager; }
render_texture *overlay() const { return m_overlaytexture; }
int orientation() const { return m_user.m_orientation; }
float xscale() const { return m_user.m_xscale; }
float yscale() const { return m_user.m_yscale; }
float xoffset() const { return m_user.m_xoffset; }
float yoffset() const { return m_user.m_yoffset; }
bool is_empty() const { return (m_itemlist.count() == 0); }
void get_user_settings(user_settings &settings) const { settings = m_user; }
// setters
void set_overlay(bitmap_t *bitmap);
void set_user_settings(const user_settings &settings);
// empty the item list
void empty() { m_item_allocator.reclaim_all(m_itemlist); }
// add items to the list
void add_line(float x0, float y0, float x1, float y1, float width, rgb_t argb, UINT32 flags);
void add_quad(float x0, float y0, float x1, float y1, rgb_t argb, render_texture *texture, UINT32 flags);
void add_char(float x0, float y0, float height, float aspect, rgb_t argb, render_font &font, UINT16 ch);
void add_point(float x0, float y0, float diameter, rgb_t argb, UINT32 flags) { add_line(x0, y0, x0, y0, diameter, argb, flags); }
void add_rect(float x0, float y0, float x1, float y1, rgb_t argb, UINT32 flags) { add_quad(x0, y0, x1, y1, argb, NULL, flags); }
// brightness/contrast/gamma helpers
bool has_brightness_contrast_gamma_changes() const { return (m_user.m_brightness != 1.0f || m_user.m_contrast != 1.0f || m_user.m_gamma != 1.0f); }
UINT8 apply_brightness_contrast_gamma(UINT8 value);
float apply_brightness_contrast_gamma_fp(float value);
const rgb_t *bcg_lookup_table(int texformat, palette_t *palette = NULL);
private:
// an item describes a high level primitive that is added to a container
class item
{
friend class render_container;
friend class simple_list<item>;
public:
// getters
item *next() const { return m_next; }
UINT8 type() const { return m_type; }
const render_bounds &bounds() const { return m_bounds; }
const render_color &color() const { return m_color; }
UINT32 flags() const { return m_flags; }
UINT32 internal() const { return m_internal; }
float width() const { return m_width; }
render_texture *texture() const { return m_texture; }
private:
// internal state
item * m_next; // pointer to the next element in the list
UINT8 m_type; // type of element
render_bounds m_bounds; // bounds of the element
render_color m_color; // RGBA factors
UINT32 m_flags; // option flags
UINT32 m_internal; // internal flags
float m_width; // width of the line (lines only)
render_texture * m_texture; // pointer to the source texture (quads only)
};
// generic screen overlay scaler
static void overlay_scale(bitmap_t &dest, const bitmap_t &source, const rectangle &sbounds, void *param);
// internal helpers
item *first_item() const { return m_itemlist.first(); }
item &add_generic(UINT8 type, float x0, float y0, float x1, float y1, rgb_t argb);
void recompute_lookups();
void update_palette();
// internal state
render_container * m_next; // the next container in the list
render_manager & m_manager; // reference back to the owning manager
simple_list<item> m_itemlist; // head of the item list
fixed_allocator<item> m_item_allocator; // free container items
screen_device * m_screen; // the screen device
user_settings m_user; // user settings
bitmap_t * m_overlaybitmap; // overlay bitmap
render_texture * m_overlaytexture; // overlay texture
palette_client * m_palclient; // client to the system palette
rgb_t m_bcglookup256[0x400]; // lookup table for brightness/contrast/gamma
rgb_t m_bcglookup32[0x80]; // lookup table for brightness/contrast/gamma
rgb_t m_bcglookup[0x10000]; // full palette lookup with bcg adjustements
};
/* ----- core implementation ----- */
// ======================> render_target
/* allocate base structures for the rendering system */
void render_init(running_machine *machine);
// a render_target describes a surface that is being rendered to
class render_target
{
friend resource_pool_object<render_target>::~resource_pool_object();
friend class simple_list<render_target>;
friend class render_manager;
/* return a boolean indicating if the screen is live */
int render_is_live_screen(device_t *screen);
// construction/destruction
render_target(render_manager &manager, const char *layoutfile = NULL, UINT32 flags = 0);
~render_target();
/* return the smallest maximum update rate across all targets */
float render_get_max_update_rate(void);
public:
// getters
render_target *next() const { return m_next; }
render_manager &manager() const { return m_manager; }
UINT32 width() const { return m_width; }
UINT32 height() const { return m_height; }
float pixel_aspect() const { return m_pixel_aspect; }
float max_update_rate() const { return m_max_refresh; }
int orientation() const { return m_orientation; }
int layer_config() const { return m_layerconfig; }
int view() const { return view_index(*m_curview); }
bool hidden() const { return ((m_flags & RENDER_CREATE_HIDDEN) != 0); }
bool backdrops_enabled() const { return (m_layerconfig & LAYER_CONFIG_ENABLE_BACKDROP) != 0; }
bool overlays_enabled() const { return (m_layerconfig & LAYER_CONFIG_ENABLE_OVERLAY) != 0; }
bool bezels_enabled() const { return (m_layerconfig & LAYER_CONFIG_ENABLE_BEZEL) != 0; }
bool screen_overlay_enabled() const { return (m_layerconfig & LAYER_CONFIG_ENABLE_SCREEN_OVERLAY) != 0; }
bool zoom_to_screen() const { return (m_layerconfig & LAYER_CONFIG_ZOOM_TO_SCREEN) != 0; }
bool is_ui_target() const;
int index() const;
/* select the UI target */
void render_set_ui_target(render_target *target);
// setters
void set_bounds(INT32 width, INT32 height, float pixel_aspect = 0);
void set_max_update_rate(float updates_per_second) { m_max_refresh = updates_per_second; }
void set_orientation(int orientation) { m_orientation = orientation; }
void set_layer_config(int layerconfig);
void set_view(int viewindex);
void set_max_texture_size(int maxwidth, int maxheight);
void set_backdrops_enabled(bool enable) { if (enable) m_layerconfig |= LAYER_CONFIG_ENABLE_BACKDROP; else m_layerconfig &= ~LAYER_CONFIG_ENABLE_BACKDROP; }
void set_overlays_enabled(bool enable) { if (enable) m_layerconfig |= LAYER_CONFIG_ENABLE_OVERLAY; else m_layerconfig &= ~LAYER_CONFIG_ENABLE_OVERLAY; }
void set_bezels_enabled(bool enable) { if (enable) m_layerconfig |= LAYER_CONFIG_ENABLE_BEZEL; else m_layerconfig &= ~LAYER_CONFIG_ENABLE_BEZEL; }
void set_screen_overlay_enabled(bool enable) { if (enable) m_layerconfig |= LAYER_CONFIG_ENABLE_SCREEN_OVERLAY; else m_layerconfig &= ~LAYER_CONFIG_ENABLE_SCREEN_OVERLAY; }
void set_zoom_to_screen(bool zoom) { if (zoom) m_layerconfig |= LAYER_CONFIG_ZOOM_TO_SCREEN; else m_layerconfig &= ~LAYER_CONFIG_ZOOM_TO_SCREEN; }
/* return the UI target */
render_target *render_get_ui_target(void);
// view information
const char *view_name(int viewindex);
UINT32 view_screens(int viewindex);
/* return the aspect ratio for UI fonts */
float render_get_ui_aspect(void);
// bounds computations
void compute_visible_area(INT32 target_width, INT32 target_height, float target_pixel_aspect, int target_orientation, INT32 &visible_width, INT32 &visible_height);
void compute_minimum_size(INT32 &minwidth, INT32 &minheight);
// get a primitive list
render_primitive_list &get_primitives();
// hit testing
bool map_point_container(INT32 target_x, INT32 target_y, render_container &container, float &container_x, float &container_y);
bool map_point_input(INT32 target_x, INT32 target_y, const char *&input_tag, UINT32 &input_mask, float &input_x, float &input_y);
// reference tracking
void invalidate_all(void *refptr);
// debug containers
render_container *debug_alloc();
void debug_free(render_container &container);
void debug_top(render_container &container);
private:
// internal helpers
void load_layout_files(const char *layoutfile, bool singlefile);
void add_container_primitives(render_primitive_list &list, const object_transform &xform, render_container &container, int blendmode);
void add_element_primitives(render_primitive_list &list, const object_transform &xform, const layout_element &element, int state, int blendmode);
bool map_point_internal(INT32 target_x, INT32 target_y, render_container *container, float &mapped_x, float &mapped_y, view_item *&mapped_item);
// config callbacks
void config_load(xml_data_node &targetnode);
bool config_save(xml_data_node &targetnode);
// view lookups
layout_view *view_by_index(int index) const;
int view_index(layout_view &view) const;
// optimized clearing
void init_clear_extents();
bool remove_clear_extent(const render_bounds &bounds);
void add_clear_extents(render_primitive_list &list);
void add_clear_and_optimize_primitive_list(render_primitive_list &list);
// constants
static const int NUM_PRIMLISTS = 3;
static const int MAX_CLEAR_EXTENTS = 1000;
// internal state
render_target * m_next; // link to next target
render_manager & m_manager; // reference to our owning manager
layout_view * m_curview; // current view
layout_file * m_filelist; // list of layout files
UINT32 m_flags; // creation flags
render_primitive_list m_primlist[NUM_PRIMLISTS]; // list of primitives
int m_listindex; // index of next primlist to use
INT32 m_width; // width in pixels
INT32 m_height; // height in pixels
render_bounds m_bounds; // bounds of the target
float m_pixel_aspect; // aspect ratio of individual pixels
float m_max_refresh; // maximum refresh rate, 0 or if none
int m_orientation; // orientation
int m_layerconfig; // layer configuration
layout_view * m_base_view; // the view at the time of first frame
int m_base_orientation; // the orientation at the time of first frame
int m_base_layerconfig; // the layer configuration at the time of first frame
int m_maxtexwidth; // maximum width of a texture
int m_maxtexheight; // maximum height of a texture
simple_list<render_container> m_debug_containers; // list of debug containers
INT32 m_clear_extent_count; // number of clear extents
INT32 m_clear_extents[MAX_CLEAR_EXTENTS]; // array of clear extents
};
// ======================> render_manager
/* ----- render target management ----- */
// contains machine-global information and operations
class render_manager
{
friend class render_target;
/* allocate a new render target */
render_target *render_target_alloc(running_machine *machine, const char *layout, UINT32 flags);
public:
// construction/destruction
render_manager(running_machine &machine);
~render_manager();
/* free memory for a render target */
void render_target_free(render_target *target);
// getters
running_machine &machine() const { return m_machine; }
/* get a render_target by index */
render_target *render_target_get_indexed(int index);
// global queries
bool is_live(screen_device &screen) const;
float max_update_rate() const;
/* return the name of the indexed view, or NULL if it doesn't exist */
const char *render_target_get_view_name(render_target *target, int viewindex);
// targets
render_target *target_alloc(const char *layoutfile = NULL, UINT32 flags = 0);
void target_free(render_target *target);
render_target *first_target() const { return m_targetlist.first(); }
render_target *target_by_index(int index) const;
/* return a bitmask of which screens are visible on a given view */
UINT32 render_target_get_view_screens(render_target *target, int viewindex);
// UI targets
render_target &ui_target() const { assert(m_ui_target != NULL); return *m_ui_target; }
void set_ui_target(render_target &target) { m_ui_target = &target; }
float ui_aspect();
/* get the bounds and pixel aspect of a target */
void render_target_get_bounds(render_target *target, INT32 *width, INT32 *height, float *pixel_aspect);
// screen containers
render_container *container_for_screen(screen_device *screen);
/* set the bounds and pixel aspect of a target */
void render_target_set_bounds(render_target *target, INT32 width, INT32 height, float pixel_aspect);
// UI containers
render_container &ui_container() const { assert(m_ui_container != NULL); return *m_ui_container; }
/* get the maximum update rate (refresh rate) of a target, or 0 if no maximum */
float render_target_get_max_update_rate(render_target *target);
// textures
render_texture *texture_alloc(texture_scaler_func scaler = NULL, void *param = NULL);
void texture_free(render_texture *texture);
/* set the maximum update rate (refresh rate) of a target, or 0 if no maximum */
void render_target_set_max_update_rate(render_target *target, float updates_per_second);
// reference tracking
void invalidate_all(void *refptr);
/* get the orientation of a target */
int render_target_get_orientation(render_target *target);
private:
// containers
render_container *container_alloc(screen_device *screen = NULL);
void container_free(render_container *container);
/* set the orientation of a target */
void render_target_set_orientation(render_target *target, int orientation);
// config callbacks
static void config_load_static(running_machine *machine, int config_type, xml_data_node *parentnode);
static void config_save_static(running_machine *machine, int config_type, xml_data_node *parentnode);
void config_load(int config_type, xml_data_node *parentnode);
void config_save(int config_type, xml_data_node *parentnode);
/* get the layer config of a target */
int render_target_get_layer_config(render_target *target);
// internal state
running_machine & m_machine; // reference back to the machine
/* set the layer config of a target */
void render_target_set_layer_config(render_target *target, int layerconfig);
// array of live targets
simple_list<render_target> m_targetlist; // list of targets
render_target * m_ui_target; // current UI target
/* return the currently selected view index */
int render_target_get_view(render_target *target);
// texture lists
UINT32 m_live_textures; // number of live textures
fixed_allocator<render_texture> m_texture_allocator;// texture allocator
/* dynamically change the view for a target */
void render_target_set_view(render_target *target, int viewindex);
/* set the upper bound on the texture size */
void render_target_set_max_texture_size(render_target *target, int maxwidth, int maxheight);
/* compute the visible area for the given target with the current layout and proposed new parameters */
void render_target_compute_visible_area(render_target *target, INT32 target_width, INT32 target_height, float target_pixel_aspect, int target_orientation, INT32 *visible_width, INT32 *visible_height);
/* get the "minimum" size of a target, which is the smallest bounds that will ensure at least
1 target pixel per source pixel for all included screens */
void render_target_get_minimum_size(render_target *target, INT32 *minwidth, INT32 *minheight);
/* return a list of primitives for a given render target */
const render_primitive_list *render_target_get_primitives(render_target *target);
/* attempts to map a point on the specified render_target to the specified container, if possible */
int render_target_map_point_container(render_target *target, INT32 target_x, INT32 target_y, render_container *container, float *container_x, float *container_y);
/* attempts to map a point on the specified render_target to the specified container, if possible */
int render_target_map_point_input(render_target *target, INT32 target_x, INT32 target_y, const char **input_tag, UINT32 *input_mask, float *input_x, float *input_y);
// containers for the UI and for screens
render_container * m_ui_container; // UI container
simple_list<render_container> m_screen_container_list; // list of containers for the screen
};
/* ----- render texture management ----- */
/* allocate a new texture */
render_texture *render_texture_alloc(texture_scaler_func scaler, void *param);
/* free an allocated texture */
void render_texture_free(render_texture *texture);
/* set a new source bitmap */
void render_texture_set_bitmap(render_texture *texture, bitmap_t *bitmap, const rectangle *sbounds, int format, palette_t *palette);
/* generic high quality resampling scaler */
void render_texture_hq_scale(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param);
/* ----- render containers ----- */
/* empty a container in preparation for new stuff */
void render_container_empty(render_container *container);
/* return true if a container has nothing in it */
int render_container_is_empty(render_container *container);
/* get the current user settings for a container */
void render_container_get_user_settings(render_container *container, render_container_user_settings *settings);
/* set the current user settings for a container */
void render_container_set_user_settings(render_container *container, const render_container_user_settings *settings);
/* set the overlay bitmap for the container */
void render_container_set_overlay(render_container *container, bitmap_t *bitmap);
/* return a pointer to the UI container */
render_container *render_container_get_ui(void);
/* return a pointer to the container for the given screen */
render_container *render_container_get_screen(screen_device *screen);
/* add a line item to the specified container */
void render_container_add_line(render_container *container, float x0, float y0, float x1, float y1, float width, rgb_t argb, UINT32 flags);
/* add a quad item to the specified container */
void render_container_add_quad(render_container *container, float x0, float y0, float x1, float y1, rgb_t argb, render_texture *texture, UINT32 flags);
/* add a char item to the specified container */
void render_container_add_char(render_container *container, float x0, float y0, float height, float aspect, rgb_t argb, render_font *font, UINT16 ch);
/* "drawable" handling for internal debugger */
render_container *render_debug_alloc(render_target *target);
void render_debug_free(render_target *target, render_container *container);
void render_debug_top(render_target *target, render_container *container);
#endif /* __RENDER_H__ */
#endif // __RENDER_H__

11
src/emu/rendersw.c
View File

@ -2333,24 +2333,27 @@ static void FUNC_PREFIX(setup_and_draw_textured_quad)(const render_primitive *pr
using a software rasterizer
-------------------------------------------------*/
static void FUNC_PREFIX(draw_primitives)(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch)
static void FUNC_PREFIX(draw_primitives)(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch)
{
const render_primitive *prim;
/* loop over the list and render each element */
for (prim = primlist; prim != NULL; prim = prim->next)
for (prim = primlist.first(); prim != NULL; prim = prim->next())
switch (prim->type)
{
case RENDER_PRIMITIVE_LINE:
case render_primitive::LINE:
FUNC_PREFIX(draw_line)(prim, dstdata, width, height, pitch);
break;
case RENDER_PRIMITIVE_QUAD:
case render_primitive::QUAD:
if (!prim->texture.base)
FUNC_PREFIX(draw_rect)(prim, dstdata, width, height, pitch);
else
FUNC_PREFIX(setup_and_draw_textured_quad)(prim, dstdata, width, height, pitch);
break;
default:
throw emu_fatalerror("Unexpected render_primitive type");
}
}

21
src/emu/rendfont.c
View File

@ -52,6 +52,7 @@ struct _render_font_char
/*typedef struct _render_font render_font; -- defined in rendfont.h */
struct _render_font
{
running_machine * machine;
int format; /* format of font data */
int height; /* height of the font, from ascent to descent */
int yoffs; /* y offset from baseline to descent */
@ -136,7 +137,7 @@ INLINE render_font_char *get_char(render_font *font, unicode_char chnum)
and load the BDF file
-------------------------------------------------*/
render_font *render_font_alloc(const char *filename)
render_font *render_font_alloc(running_machine &machine, const char *filename)
{
file_error filerr;
mame_file *ramfile;
@ -144,6 +145,7 @@ render_font *render_font_alloc(const char *filename)
/* allocate and clear memory */
font = global_alloc_clear(render_font);
font->machine = &machine;
/* attempt to load the cached version of the font first */
if (filename != NULL && render_font_load_cached_bdf(font, filename) == 0)
@ -152,6 +154,7 @@ render_font *render_font_alloc(const char *filename)
/* if we failed, clean up and realloc */
render_font_free(font);
font = global_alloc_clear(render_font);
font->machine = &machine;
/* load the raw data instead */
filerr = mame_fopen_ram(font_uismall, sizeof(font_uismall), OPEN_FLAG_READ, &ramfile);
@ -183,8 +186,7 @@ void render_font_free(render_font *font)
for (charnum = 0; charnum < 256; charnum++)
{
render_font_char *ch = &font->chars[tablenum][charnum];
if (ch->texture != NULL)
render_texture_free(ch->texture);
font->machine->render().texture_free(ch->texture);
global_free(ch->bitmap);
}
@ -274,8 +276,8 @@ static void render_font_char_expand(render_font *font, render_font_char *ch)
}
/* wrap a texture around the bitmap */
ch->texture = render_texture_alloc(render_texture_hq_scale, NULL);
render_texture_set_bitmap(ch->texture, ch->bitmap, NULL, TEXFORMAT_ARGB32, NULL);
ch->texture = font->machine->render().texture_alloc(render_texture::hq_scale);
ch->texture->set_bitmap(ch->bitmap, NULL, TEXFORMAT_ARGB32);
}
@ -343,7 +345,11 @@ void render_font_get_scaled_bitmap_and_bounds(render_font *font, bitmap_t *dest,
origheight = dest->height;
dest->width = bounds->max_x - bounds->min_x;
dest->height = bounds->max_y - bounds->min_y;
render_texture_hq_scale(dest, ch->bitmap, NULL, NULL);
rectangle clip;
clip.min_x = clip.min_y = 0;
clip.max_x = ch->bitmap->width - 1;
clip.max_y = ch->bitmap->height - 1;
render_texture::hq_scale(*dest, *ch->bitmap, clip, NULL);
dest->width = origwidth;
dest->height = origheight;
}
@ -812,8 +818,7 @@ static int render_font_save_cached(render_font *font, const char *filename, UINT
goto error;
/* free the bitmap and texture */
if (ch->texture != NULL)
render_texture_free(ch->texture);
font->machine->render().texture_free(ch->texture);
ch->texture = NULL;
global_free(ch->bitmap);
ch->bitmap = NULL;

2
src/emu/rendfont.h
View File

@ -20,7 +20,7 @@
FUNCTION PROTOTYPES
***************************************************************************/
render_font *render_font_alloc(const char *filename);
render_font *render_font_alloc(running_machine &machine, const char *filename);
void render_font_free(render_font *font);
INT32 render_font_get_pixel_height(render_font *font);
render_texture *render_font_get_char_texture_and_bounds(render_font *font, float height, float aspect, unicode_char ch, render_bounds *bounds);

496
src/emu/rendlay.c
View File

File diff suppressed because it is too large Load Diff

3
src/emu/rendlay.h
View File

@ -96,6 +96,7 @@ struct _element_texture
struct _layout_element
{
layout_element * next; /* link to next element */
running_machine * machine;
const char * name; /* name of this element */
element_component * complist; /* head of the list of components */
int defstate; /* default state of this element */
@ -164,7 +165,7 @@ void layout_view_recompute(layout_view *view, int layerconfig);
/* ----- layout file parsing ----- */
layout_file *layout_file_load(const machine_config *config, const char *dirname, const char *filename);
layout_file *layout_file_load(running_machine &machine, const char *dirname, const char *filename);
void layout_file_free(layout_file *file);

2
src/emu/softlist.c
View File

@ -1455,7 +1455,7 @@ void ui_image_menu_software(running_machine *machine, ui_menu *menu, void *param
if (event != NULL && event->iptkey == IPT_UI_SELECT)
{
ui_menu *child_menu = ui_menu_alloc(machine, render_container_get_ui(), ui_mess_menu_software_list, NULL);
ui_menu *child_menu = ui_menu_alloc(machine, &machine->render().ui_container(), ui_mess_menu_software_list, NULL);
software_menu_state *child_menustate = (software_menu_state *)ui_menu_alloc_state(child_menu, sizeof(*child_menustate), NULL);
child_menustate->list_name = (char *)event->itemref;
child_menustate->image = image;

155
src/emu/ui.c
View File

@ -240,7 +240,7 @@ int ui_init(running_machine *machine)
machine->add_notifier(MACHINE_NOTIFY_EXIT, ui_exit);
/* allocate the font and messagebox string */
ui_font = render_font_alloc("ui.bdf");
ui_font = render_font_alloc(*machine, "ui.bdf");
/* initialize the other UI bits */
ui_menu_init(machine);
@ -374,7 +374,7 @@ void ui_set_startup_text(running_machine *machine, const char *text, int force)
void ui_update_and_render(running_machine *machine, render_container *container)
{
/* always start clean */
render_container_empty(container);
container->empty();
/* if we're paused, dim the whole screen */
if (machine->phase() >= MACHINE_PHASE_RESET && (single_step || machine->paused()))
@ -385,7 +385,7 @@ void ui_update_and_render(running_machine *machine, render_container *container)
if (alpha > 255)
alpha = 255;
if (alpha >= 0)
render_container_add_rect(container, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(alpha,0x00,0x00,0x00), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_rect(0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(alpha,0x00,0x00,0x00), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
/* render any cheat stuff at the bottom */
@ -422,17 +422,14 @@ render_font *ui_get_font(void)
of a line
-------------------------------------------------*/
float ui_get_line_height(void)
float ui_get_line_height(running_machine &machine)
{
INT32 raw_font_pixel_height = render_font_get_pixel_height(ui_font);
INT32 target_pixel_width, target_pixel_height;
render_target &ui_target = machine.render().ui_target();
INT32 target_pixel_height = ui_target.height();
float one_to_one_line_height;
float target_aspect;
float scale_factor;
/* get info about the UI target */
render_target_get_bounds(render_get_ui_target(), &target_pixel_width, &target_pixel_height, &target_aspect);
/* compute the font pixel height at the nominal size */
one_to_one_line_height = (float)raw_font_pixel_height / (float)target_pixel_height;
@ -470,9 +467,9 @@ float ui_get_line_height(void)
single character
-------------------------------------------------*/
float ui_get_char_width(unicode_char ch)
float ui_get_char_width(running_machine &machine, unicode_char ch)
{
return render_font_get_char_width(ui_font, ui_get_line_height(), render_get_ui_aspect(), ch);
return render_font_get_char_width(ui_font, ui_get_line_height(machine), machine.render().ui_aspect(), ch);
}
@ -481,9 +478,9 @@ float ui_get_char_width(unicode_char ch)
character string
-------------------------------------------------*/
float ui_get_string_width(const char *s)
float ui_get_string_width(running_machine &machine, const char *s)
{
return render_font_get_utf8string_width(ui_font, ui_get_line_height(), render_get_ui_aspect(), s);
return render_font_get_utf8string_width(ui_font, ui_get_line_height(machine), machine.render().ui_aspect(), s);
}
@ -495,11 +492,11 @@ float ui_get_string_width(const char *s)
void ui_draw_outlined_box(render_container *container, float x0, float y0, float x1, float y1, rgb_t backcolor)
{
render_container_add_rect(container, x0, y0, x1, y1, backcolor, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
render_container_add_line(container, x0, y0, x1, y0, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
render_container_add_line(container, x1, y0, x1, y1, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
render_container_add_line(container, x1, y1, x0, y1, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
render_container_add_line(container, x0, y1, x0, y0, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_rect(x0, y0, x1, y1, backcolor, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_line(x0, y0, x1, y0, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_line(x1, y0, x1, y1, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_line(x1, y1, x0, y1, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_line(x0, y1, x0, y0, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
@ -521,7 +518,8 @@ void ui_draw_text(render_container *container, const char *buf, float x, float y
void ui_draw_text_full(render_container *container, const char *origs, float x, float y, float origwrapwidth, int justify, int wrap, int draw, rgb_t fgcolor, rgb_t bgcolor, float *totalwidth, float *totalheight)
{
float lineheight = ui_get_line_height();
running_machine &machine = container->manager().machine();
float lineheight = ui_get_line_height(machine);
const char *ends = origs + strlen(origs);
float wrapwidth = origwrapwidth;
const char *s = origs;
@ -576,7 +574,7 @@ void ui_draw_text_full(render_container *container, const char *origs, float x,
break;
/* get the width of this character */
chwidth = ui_get_char_width(schar);
chwidth = ui_get_char_width(machine, schar);
/* if we hit a space, remember the location and width *without* the space */
if (schar == ' ')
@ -620,7 +618,7 @@ void ui_draw_text_full(render_container *container, const char *origs, float x,
if (scharcount == -1)
break;
curwidth -= ui_get_char_width(schar);
curwidth -= ui_get_char_width(machine, schar);
}
}
@ -628,7 +626,7 @@ void ui_draw_text_full(render_container *container, const char *origs, float x,
else if (wrap == WRAP_TRUNCATE)
{
/* add in the width of the ... */
curwidth += 3.0f * ui_get_char_width('.');
curwidth += 3.0f * ui_get_char_width(machine, '.');
/* while we are above the wrap width, back up one character */
while (curwidth > wrapwidth && s > linestart)
@ -639,7 +637,7 @@ void ui_draw_text_full(render_container *container, const char *origs, float x,
if (scharcount == -1)
break;
curwidth -= ui_get_char_width(schar);
curwidth -= ui_get_char_width(machine, schar);
}
}
}
@ -656,7 +654,7 @@ void ui_draw_text_full(render_container *container, const char *origs, float x,
/* if opaque, add a black box */
if (draw == DRAW_OPAQUE)
render_container_add_rect(container, curx, cury, curx + curwidth, cury + lineheight, bgcolor, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_rect(curx, cury, curx + curwidth, cury + lineheight, bgcolor, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
/* loop from the line start and add the characters */
while (linestart < s)
@ -669,8 +667,8 @@ void ui_draw_text_full(render_container *container, const char *origs, float x,
if (draw != DRAW_NONE)
{
render_container_add_char(container, curx, cury, lineheight, render_get_ui_aspect(), fgcolor, ui_font, linechar);
curx += ui_get_char_width(linechar);
container->add_char(curx, cury, lineheight, machine.render().ui_aspect(), fgcolor, *ui_font, linechar);
curx += ui_get_char_width(machine, linechar);
}
linestart += linecharcount;
}
@ -678,12 +676,12 @@ void ui_draw_text_full(render_container *container, const char *origs, float x,
/* append ellipses if needed */
if (wrap == WRAP_TRUNCATE && *s != 0 && draw != DRAW_NONE)
{
render_container_add_char(container, curx, cury, lineheight, render_get_ui_aspect(), fgcolor, ui_font, '.');
curx += ui_get_char_width('.');
render_container_add_char(container, curx, cury, lineheight, render_get_ui_aspect(), fgcolor, ui_font, '.');
curx += ui_get_char_width('.');
render_container_add_char(container, curx, cury, lineheight, render_get_ui_aspect(), fgcolor, ui_font, '.');
curx += ui_get_char_width('.');
container->add_char(curx, cury, lineheight, machine.render().ui_aspect(), fgcolor, *ui_font, '.');
curx += ui_get_char_width(machine, '.');
container->add_char(curx, cury, lineheight, machine.render().ui_aspect(), fgcolor, *ui_font, '.');
curx += ui_get_char_width(machine, '.');
container->add_char(curx, cury, lineheight, machine.render().ui_aspect(), fgcolor, *ui_font, '.');
curx += ui_get_char_width(machine, '.');
}
/* if we're not word-wrapping, we're done */
@ -732,7 +730,7 @@ void ui_draw_text_box(render_container *container, const char *text, int justify
ui_draw_text_full(container, text, 0, 0, 1.0f - 2.0f * UI_BOX_LR_BORDER,
justify, WRAP_WORD, DRAW_NONE, ARGB_WHITE, ARGB_BLACK, &target_width, &target_height);
if (target_height > 1.0f - 2.0f * UI_BOX_TB_BORDER)
target_height = floor((1.0f - 2.0f * UI_BOX_TB_BORDER) / ui_get_line_height()) * ui_get_line_height();
target_height = floor((1.0f - 2.0f * UI_BOX_TB_BORDER) / ui_get_line_height(container->manager().machine())) * ui_get_line_height(container->manager().machine());
/* determine the target location */
target_x = xpos - 0.5f * target_width;
@ -1848,18 +1846,17 @@ static INT32 slider_refresh(running_machine *machine, void *arg, astring *string
static INT32 slider_brightness(running_machine *machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
render_container *container = render_container_get_screen(screen);
render_container_user_settings settings;
render_container::user_settings settings;
render_container_get_user_settings(container, &settings);
screen->container().get_user_settings(settings);
if (newval != SLIDER_NOCHANGE)
{
settings.brightness = (float)newval * 0.001f;
render_container_set_user_settings(container, &settings);
settings.m_brightness = (float)newval * 0.001f;
screen->container().set_user_settings(settings);
}
if (string != NULL)
string->printf("%.3f", settings.brightness);
return floor(settings.brightness * 1000.0f + 0.5f);
string->printf("%.3f", settings.m_brightness);
return floor(settings.m_brightness * 1000.0f + 0.5f);
}
@ -1871,18 +1868,17 @@ static INT32 slider_brightness(running_machine *machine, void *arg, astring *str
static INT32 slider_contrast(running_machine *machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
render_container *container = render_container_get_screen(screen);
render_container_user_settings settings;
render_container::user_settings settings;
render_container_get_user_settings(container, &settings);
screen->container().get_user_settings(settings);
if (newval != SLIDER_NOCHANGE)
{
settings.contrast = (float)newval * 0.001f;
render_container_set_user_settings(container, &settings);
settings.m_contrast = (float)newval * 0.001f;
screen->container().set_user_settings(settings);
}
if (string != NULL)
string->printf("%.3f", settings.contrast);
return floor(settings.contrast * 1000.0f + 0.5f);
string->printf("%.3f", settings.m_contrast);
return floor(settings.m_contrast * 1000.0f + 0.5f);
}
@ -1893,18 +1889,17 @@ static INT32 slider_contrast(running_machine *machine, void *arg, astring *strin
static INT32 slider_gamma(running_machine *machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
render_container *container = render_container_get_screen(screen);
render_container_user_settings settings;
render_container::user_settings settings;
render_container_get_user_settings(container, &settings);
screen->container().get_user_settings(settings);
if (newval != SLIDER_NOCHANGE)
{
settings.gamma = (float)newval * 0.001f;
render_container_set_user_settings(container, &settings);
settings.m_gamma = (float)newval * 0.001f;
screen->container().set_user_settings(settings);
}
if (string != NULL)
string->printf("%.3f", settings.gamma);
return floor(settings.gamma * 1000.0f + 0.5f);
string->printf("%.3f", settings.m_gamma);
return floor(settings.m_gamma * 1000.0f + 0.5f);
}
@ -1916,18 +1911,17 @@ static INT32 slider_gamma(running_machine *machine, void *arg, astring *string,
static INT32 slider_xscale(running_machine *machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
render_container *container = render_container_get_screen(screen);
render_container_user_settings settings;
render_container::user_settings settings;
render_container_get_user_settings(container, &settings);
screen->container().get_user_settings(settings);
if (newval != SLIDER_NOCHANGE)
{
settings.xscale = (float)newval * 0.001f;
render_container_set_user_settings(container, &settings);
settings.m_xscale = (float)newval * 0.001f;
screen->container().set_user_settings(settings);
}
if (string != NULL)
string->printf("%.3f", settings.xscale);
return floor(settings.xscale * 1000.0f + 0.5f);
string->printf("%.3f", settings.m_xscale);
return floor(settings.m_xscale * 1000.0f + 0.5f);
}
@ -1939,18 +1933,17 @@ static INT32 slider_xscale(running_machine *machine, void *arg, astring *string,
static INT32 slider_yscale(running_machine *machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
render_container *container = render_container_get_screen(screen);
render_container_user_settings settings;
render_container::user_settings settings;
render_container_get_user_settings(container, &settings);
screen->container().get_user_settings(settings);
if (newval != SLIDER_NOCHANGE)
{
settings.yscale = (float)newval * 0.001f;
render_container_set_user_settings(container, &settings);
settings.m_yscale = (float)newval * 0.001f;
screen->container().set_user_settings(settings);
}
if (string != NULL)
string->printf("%.3f", settings.yscale);
return floor(settings.yscale * 1000.0f + 0.5f);
string->printf("%.3f", settings.m_yscale);
return floor(settings.m_yscale * 1000.0f + 0.5f);
}
@ -1962,18 +1955,17 @@ static INT32 slider_yscale(running_machine *machine, void *arg, astring *string,
static INT32 slider_xoffset(running_machine *machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
render_container *container = render_container_get_screen(screen);
render_container_user_settings settings;
render_container::user_settings settings;
render_container_get_user_settings(container, &settings);
screen->container().get_user_settings(settings);
if (newval != SLIDER_NOCHANGE)
{
settings.xoffset = (float)newval * 0.001f;
render_container_set_user_settings(container, &settings);
settings.m_xoffset = (float)newval * 0.001f;
screen->container().set_user_settings(settings);
}
if (string != NULL)
string->printf("%.3f", settings.xoffset);
return floor(settings.xoffset * 1000.0f + 0.5f);
string->printf("%.3f", settings.m_xoffset);
return floor(settings.m_xoffset * 1000.0f + 0.5f);
}
@ -1985,18 +1977,17 @@ static INT32 slider_xoffset(running_machine *machine, void *arg, astring *string
static INT32 slider_yoffset(running_machine *machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
render_container *container = render_container_get_screen(screen);
render_container_user_settings settings;
render_container::user_settings settings;
render_container_get_user_settings(container, &settings);
screen->container().get_user_settings(settings);
if (newval != SLIDER_NOCHANGE)
{
settings.yoffset = (float)newval * 0.001f;
render_container_set_user_settings(container, &settings);
settings.m_yoffset = (float)newval * 0.001f;
screen->container().set_user_settings(settings);
}
if (string != NULL)
string->printf("%.3f", settings.yoffset);
return floor(settings.yoffset * 1000.0f + 0.5f);
string->printf("%.3f", settings.m_yoffset);
return floor(settings.m_yoffset * 1000.0f + 0.5f);
}

6
src/emu/ui.h
View File

@ -136,11 +136,11 @@ void ui_update_and_render(running_machine *machine, render_container *container)
render_font *ui_get_font(void);
/* returns the line height of the font used by the UI system */
float ui_get_line_height(void);
float ui_get_line_height(running_machine &machine);
/* returns the width of a character or string in the UI font */
float ui_get_char_width(unicode_char ch);
float ui_get_string_width(const char *s);
float ui_get_char_width(running_machine &machine, unicode_char ch);
float ui_get_string_width(running_machine &machine, const char *s);
/* draw an outlined box filled with a given color */
void ui_draw_outlined_box(render_container *container, float x0, float y0, float x1, float y1, rgb_t backcolor);

89
src/emu/uigfx.c
View File

@ -136,8 +136,7 @@ void ui_gfx_init(running_machine *machine)
static void ui_gfx_exit(running_machine &machine)
{
/* free the texture */
if (ui_gfx.texture != NULL)
render_texture_free(ui_gfx.texture);
machine.render().texture_free(ui_gfx.texture);
ui_gfx.texture = NULL;
/* free the bitmap */
@ -253,8 +252,8 @@ static void palette_handler(running_machine *machine, render_container *containe
int x, y, skip;
/* add a half character padding for the box */
chheight = ui_get_line_height();
chwidth = render_font_get_char_width(ui_font, chheight, render_get_ui_aspect(), '0');
chheight = ui_get_line_height(*machine);
chwidth = render_font_get_char_width(ui_font, chheight, machine->render().ui_aspect(), '0');
boxbounds.x0 = 0.0f + 0.5f * chwidth;
boxbounds.x1 = 1.0f - 0.5f * chwidth;
boxbounds.y0 = 0.0f + 0.5f * chheight;
@ -274,7 +273,7 @@ static void palette_handler(running_machine *machine, render_container *containe
cellboxbounds.y0 += 3.0f * chheight;
/* figure out the title and expand the outer box to fit */
titlewidth = render_font_get_string_width(ui_font, chheight, render_get_ui_aspect(), title);
titlewidth = render_font_get_string_width(ui_font, chheight, machine->render().ui_aspect(), title);
x0 = 0.0f;
if (boxbounds.x1 - boxbounds.x0 < titlewidth + chwidth)
x0 = boxbounds.x0 - (0.5f - 0.5f * (titlewidth + chwidth));
@ -287,8 +286,8 @@ static void palette_handler(running_machine *machine, render_container *containe
y0 = boxbounds.y0 + 0.5f * chheight;
for (x = 0; title[x] != 0; x++)
{
render_container_add_char(container, x0, y0, chheight, render_get_ui_aspect(), ARGB_WHITE, ui_font, title[x]);
x0 += render_font_get_char_width(ui_font, chheight, render_get_ui_aspect(), title[x]);
container->add_char(x0, y0, chheight, machine->render().ui_aspect(), ARGB_WHITE, *ui_font, title[x]);
x0 += render_font_get_char_width(ui_font, chheight, machine->render().ui_aspect(), title[x]);
}
/* compute the cell size */
@ -301,12 +300,12 @@ static void palette_handler(running_machine *machine, render_container *containe
{
x0 = boxbounds.x0 + 6.0f * chwidth + (float)x * cellwidth;
y0 = boxbounds.y0 + 2.0f * chheight;
render_container_add_char(container, x0 + 0.5f * (cellwidth - chwidth), y0, chheight, render_get_ui_aspect(), ARGB_WHITE, ui_font, "0123456789ABCDEF"[x & 0xf]);
container->add_char(x0 + 0.5f * (cellwidth - chwidth), y0, chheight, machine->render().ui_aspect(), ARGB_WHITE, *ui_font, "0123456789ABCDEF"[x & 0xf]);
/* if we're skipping, draw a point between the character and the box to indicate which */
/* one it's referring to */
if (skip != 0)
render_container_add_point(container, x0 + 0.5f * cellwidth, 0.5f * (y0 + chheight + cellboxbounds.y0), UI_LINE_WIDTH, ARGB_WHITE, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_point(x0 + 0.5f * cellwidth, 0.5f * (y0 + chheight + cellboxbounds.y0), UI_LINE_WIDTH, ARGB_WHITE, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
/* draw the side column headers */
@ -323,14 +322,14 @@ static void palette_handler(running_machine *machine, render_container *containe
x0 = boxbounds.x0 + 5.5f * chwidth;
y0 = boxbounds.y0 + 3.5f * chheight + (float)y * cellheight;
if (skip != 0)
render_container_add_point(container, 0.5f * (x0 + cellboxbounds.x0), y0 + 0.5f * cellheight, UI_LINE_WIDTH, ARGB_WHITE, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_point(0.5f * (x0 + cellboxbounds.x0), y0 + 0.5f * cellheight, UI_LINE_WIDTH, ARGB_WHITE, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
/* draw the row header */
sprintf(buffer, "%5X", state->palette.offset + y * state->palette.count);
for (x = 4; x >= 0; x--)
{
x0 -= render_font_get_char_width(ui_font, chheight, render_get_ui_aspect(), buffer[x]);
render_container_add_char(container, x0, y0 + 0.5f * (cellheight - chheight), chheight, render_get_ui_aspect(), ARGB_WHITE, ui_font, buffer[x]);
x0 -= render_font_get_char_width(ui_font, chheight, machine->render().ui_aspect(), buffer[x]);
container->add_char(x0, y0 + 0.5f * (cellheight - chheight), chheight, machine->render().ui_aspect(), ARGB_WHITE, *ui_font, buffer[x]);
}
}
@ -342,7 +341,7 @@ static void palette_handler(running_machine *machine, render_container *containe
if (index < total)
{
pen_t pen = state->palette.which ? colortable_palette_get_color(machine->colortable, index) : raw_color[index];
render_container_add_rect(container, cellboxbounds.x0 + x * cellwidth, cellboxbounds.y0 + y * cellheight,
container->add_rect(cellboxbounds.x0 + x * cellwidth, cellboxbounds.y0 + y * cellheight,
cellboxbounds.x0 + (x + 1) * cellwidth, cellboxbounds.y0 + (y + 1) * cellheight,
0xff000000 | pen, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
@ -440,19 +439,17 @@ static void gfxset_handler(running_machine *machine, render_container *container
render_bounds cellboxbounds;
render_bounds boxbounds;
int cellboxwidth, cellboxheight;
int targwidth, targheight;
int targwidth = machine->render().ui_target().width();
int targheight = machine->render().ui_target().height();
int cellxpix, cellypix;
int xcells, ycells;
int pixelscale = 0;
int x, y, skip;
char title[100];
/* get the bounds of our target */
render_target_get_bounds(render_get_ui_target(), &targwidth, &targheight, NULL);
/* add a half character padding for the box */
chheight = ui_get_line_height();
chwidth = render_font_get_char_width(ui_font, chheight, render_get_ui_aspect(), '0');
chheight = ui_get_line_height(*machine);
chwidth = render_font_get_char_width(ui_font, chheight, machine->render().ui_aspect(), '0');
boxbounds.x0 = 0.0f + 0.5f * chwidth;
boxbounds.x1 = 1.0f - 0.5f * chwidth;
boxbounds.y0 = 0.0f + 0.5f * chheight;
@ -517,7 +514,7 @@ static void gfxset_handler(running_machine *machine, render_container *container
/* figure out the title and expand the outer box to fit */
for (x = 0; x < MAX_GFX_ELEMENTS && machine->gfx[x] != NULL; x++) ;
sprintf(title, "GFX %d/%d %dx%d COLOR %X", state->gfxset.set, x - 1, gfx->width, gfx->height, state->gfxset.color[set]);
titlewidth = render_font_get_string_width(ui_font, chheight, render_get_ui_aspect(), title);
titlewidth = render_font_get_string_width(ui_font, chheight, machine->render().ui_aspect(), title);
x0 = 0.0f;
if (boxbounds.x1 - boxbounds.x0 < titlewidth + chwidth)
x0 = boxbounds.x0 - (0.5f - 0.5f * (titlewidth + chwidth));
@ -530,8 +527,8 @@ static void gfxset_handler(running_machine *machine, render_container *container
y0 = boxbounds.y0 + 0.5f * chheight;
for (x = 0; title[x] != 0; x++)
{
render_container_add_char(container, x0, y0, chheight, render_get_ui_aspect(), ARGB_WHITE, ui_font, title[x]);
x0 += render_font_get_char_width(ui_font, chheight, render_get_ui_aspect(), title[x]);
container->add_char(x0, y0, chheight, machine->render().ui_aspect(), ARGB_WHITE, *ui_font, title[x]);
x0 += render_font_get_char_width(ui_font, chheight, machine->render().ui_aspect(), title[x]);
}
/* draw the top column headers */
@ -540,12 +537,12 @@ static void gfxset_handler(running_machine *machine, render_container *container
{
x0 = boxbounds.x0 + 6.0f * chwidth + (float)x * cellwidth;
y0 = boxbounds.y0 + 2.0f * chheight;
render_container_add_char(container, x0 + 0.5f * (cellwidth - chwidth), y0, chheight, render_get_ui_aspect(), ARGB_WHITE, ui_font, "0123456789ABCDEF"[x & 0xf]);
container->add_char(x0 + 0.5f * (cellwidth - chwidth), y0, chheight, machine->render().ui_aspect(), ARGB_WHITE, *ui_font, "0123456789ABCDEF"[x & 0xf]);
/* if we're skipping, draw a point between the character and the box to indicate which */
/* one it's referring to */
if (skip != 0)
render_container_add_point(container, x0 + 0.5f * cellwidth, 0.5f * (y0 + chheight + boxbounds.y0 + 3.5f * chheight), UI_LINE_WIDTH, ARGB_WHITE, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_point(x0 + 0.5f * cellwidth, 0.5f * (y0 + chheight + boxbounds.y0 + 3.5f * chheight), UI_LINE_WIDTH, ARGB_WHITE, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
/* draw the side column headers */
@ -562,14 +559,14 @@ static void gfxset_handler(running_machine *machine, render_container *container
x0 = boxbounds.x0 + 5.5f * chwidth;
y0 = boxbounds.y0 + 3.5f * chheight + (float)y * cellheight;
if (skip != 0)
render_container_add_point(container, 0.5f * (x0 + boxbounds.x0 + 6.0f * chwidth), y0 + 0.5f * cellheight, UI_LINE_WIDTH, ARGB_WHITE, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
container->add_point(0.5f * (x0 + boxbounds.x0 + 6.0f * chwidth), y0 + 0.5f * cellheight, UI_LINE_WIDTH, ARGB_WHITE, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
/* draw the row header */
sprintf(buffer, "%5X", state->gfxset.offset[set] + y * xcells);
for (x = 4; x >= 0; x--)
{
x0 -= render_font_get_char_width(ui_font, chheight, render_get_ui_aspect(), buffer[x]);
render_container_add_char(container, x0, y0 + 0.5f * (cellheight - chheight), chheight, render_get_ui_aspect(), ARGB_WHITE, ui_font, buffer[x]);
x0 -= render_font_get_char_width(ui_font, chheight, machine->render().ui_aspect(), buffer[x]);
container->add_char(x0, y0 + 0.5f * (cellheight - chheight), chheight, machine->render().ui_aspect(), ARGB_WHITE, *ui_font, buffer[x]);
}
}
@ -577,7 +574,7 @@ static void gfxset_handler(running_machine *machine, render_container *container
gfxset_update_bitmap(machine, state, xcells, ycells, gfx);
/* add the final quad */
render_container_add_quad(container, boxbounds.x0 + 6.0f * chwidth, boxbounds.y0 + 3.5f * chheight,
container->add_quad(boxbounds.x0 + 6.0f * chwidth, boxbounds.y0 + 3.5f * chheight,
boxbounds.x0 + 6.0f * chwidth + (float)cellboxwidth / (float)targwidth,
boxbounds.y0 + 3.5f * chheight + (float)cellboxheight / (float)targheight,
ARGB_WHITE, state->texture, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
@ -699,14 +696,13 @@ static void gfxset_update_bitmap(running_machine *machine, ui_gfx_state *state,
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);
machine->render().texture_free(state->texture);
global_free(state->bitmap);
/* allocate new stuff */
state->bitmap = global_alloc(bitmap_t(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);
state->texture = machine->render().texture_alloc();
state->texture->set_bitmap(state->bitmap, NULL, TEXFORMAT_ARGB32);
/* force a redraw */
state->bitmap_dirty = TRUE;
@ -754,7 +750,7 @@ static void gfxset_update_bitmap(running_machine *machine, ui_gfx_state *state,
}
/* reset the texture to force an update */
render_texture_set_bitmap(state->texture, state->bitmap, NULL, TEXFORMAT_ARGB32, NULL);
state->texture->set_bitmap(state->bitmap, NULL, TEXFORMAT_ARGB32);
state->bitmap_dirty = FALSE;
}
}
@ -848,7 +844,8 @@ static void tilemap_handler(running_machine *machine, render_container *containe
float chwidth, chheight;
render_bounds mapboxbounds;
render_bounds boxbounds;
int targwidth, targheight;
int targwidth = machine->render().ui_target().width();
int targheight = machine->render().ui_target().height();
float titlewidth;
float x0, y0;
int mapboxwidth, mapboxheight;
@ -857,17 +854,14 @@ static void tilemap_handler(running_machine *machine, render_container *containe
int x, pixelscale;
char title[100];
/* get the bounds of our target */
render_target_get_bounds(render_get_ui_target(), &targwidth, &targheight, NULL);
/* get the size of the tilemap itself */
tilemap_size_by_index(machine, state->tilemap.which, &mapwidth, &mapheight);
if (state->tilemap.rotate & ORIENTATION_SWAP_XY)
{ UINT32 temp = mapwidth; mapwidth = mapheight; mapheight = temp; }
/* add a half character padding for the box */
chheight = ui_get_line_height();
chwidth = render_font_get_char_width(ui_font, chheight, render_get_ui_aspect(), '0');
chheight = ui_get_line_height(*machine);
chwidth = render_font_get_char_width(ui_font, chheight, machine->render().ui_aspect(), '0');
boxbounds.x0 = 0.0f + 0.5f * chwidth;
boxbounds.x1 = 1.0f - 0.5f * chwidth;
boxbounds.y0 = 0.0f + 0.5f * chheight;
@ -914,7 +908,7 @@ static void tilemap_handler(running_machine *machine, render_container *containe
/* figure out the title and expand the outer box to fit */
sprintf(title, "TMAP %d/%d %dx%d OFFS %d,%d", state->tilemap.which, tilemap_count(machine) - 1, mapwidth, mapheight, state->tilemap.xoffs, state->tilemap.yoffs);
titlewidth = render_font_get_string_width(ui_font, chheight, render_get_ui_aspect(), title);
titlewidth = render_font_get_string_width(ui_font, chheight, machine->render().ui_aspect(), title);
if (boxbounds.x1 - boxbounds.x0 < titlewidth + chwidth)
{
boxbounds.x0 = 0.5f - 0.5f * (titlewidth + chwidth);
@ -929,15 +923,15 @@ static void tilemap_handler(running_machine *machine, render_container *containe
y0 = boxbounds.y0 + 0.5f * chheight;
for (x = 0; title[x] != 0; x++)
{
render_container_add_char(container, x0, y0, chheight, render_get_ui_aspect(), ARGB_WHITE, ui_font, title[x]);
x0 += render_font_get_char_width(ui_font, chheight, render_get_ui_aspect(), title[x]);
container->add_char(x0, y0, chheight, machine->render().ui_aspect(), ARGB_WHITE, *ui_font, title[x]);
x0 += render_font_get_char_width(ui_font, chheight, machine->render().ui_aspect(), title[x]);
}
/* update the bitmap */
tilemap_update_bitmap(machine, state, mapboxwidth / pixelscale, mapboxheight / pixelscale);
/* add the final quad */
render_container_add_quad(container, mapboxbounds.x0, mapboxbounds.y0,
container->add_quad(mapboxbounds.x0, mapboxbounds.y0,
mapboxbounds.x1, mapboxbounds.y1,
ARGB_WHITE, state->texture,
PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXORIENT(state->tilemap.rotate));
@ -1058,14 +1052,13 @@ static void tilemap_update_bitmap(running_machine *machine, ui_gfx_state *state,
if (state->bitmap == NULL || state->texture == NULL || state->bitmap->format != screen_format || state->bitmap->width != width || state->bitmap->height != height)
{
/* free the old stuff */
if (state->texture != NULL)
render_texture_free(state->texture);
machine->render().texture_free(state->texture);
global_free(state->bitmap);
/* allocate new stuff */
state->bitmap = global_alloc(bitmap_t(width, height, screen_format));
state->texture = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(state->texture, state->bitmap, NULL, screen_texformat, palette);
state->texture = machine->render().texture_alloc();
state->texture->set_bitmap(state->bitmap, NULL, screen_texformat, palette);
/* force a redraw */
state->bitmap_dirty = TRUE;
@ -1077,7 +1070,7 @@ static void tilemap_update_bitmap(running_machine *machine, ui_gfx_state *state,
tilemap_draw_by_index(machine, state->bitmap, state->tilemap.which, state->tilemap.xoffs, state->tilemap.yoffs);
/* reset the texture to force an update */
render_texture_set_bitmap(state->texture, state->bitmap, NULL, screen_texformat, palette);
state->texture->set_bitmap(state->bitmap, NULL, screen_texformat, palette);
state->bitmap_dirty = FALSE;
}
}

26
src/emu/uiimage.c
View File

@ -147,14 +147,14 @@ static void input_character(char *buffer, size_t buffer_length, unicode_char uni
or footer text
-------------------------------------------------*/
static void extra_text_draw_box(float origx1, float origx2, float origy, float yspan, const char *text, int direction)
static void extra_text_draw_box(render_container &ui_container, float origx1, float origx2, float origy, float yspan, const char *text, int direction)
{
float text_width, text_height;
float width, maxwidth;
float x1, y1, x2, y2, temp;
/* get the size of the text */
ui_draw_text_full( render_container_get_ui(),text, 0.0f, 0.0f, 1.0f, JUSTIFY_LEFT, WRAP_WORD,
ui_draw_text_full(&ui_container,text, 0.0f, 0.0f, 1.0f, JUSTIFY_LEFT, WRAP_WORD,
DRAW_NONE, ARGB_WHITE, ARGB_BLACK, &text_width, &text_height);
width = text_width + (2 * UI_BOX_LR_BORDER);
maxwidth = MAX(width, origx2 - origx1);
@ -173,7 +173,7 @@ static void extra_text_draw_box(float origx1, float origx2, float origy, float y
}
/* draw a box */
ui_draw_outlined_box(render_container_get_ui(),x1, y1, x2, y2, UI_BACKGROUND_COLOR);
ui_draw_outlined_box(&ui_container,x1, y1, x2, y2, UI_BACKGROUND_COLOR);
/* take off the borders */
x1 += UI_BOX_LR_BORDER;
@ -182,7 +182,7 @@ static void extra_text_draw_box(float origx1, float origx2, float origy, float y
y2 -= UI_BOX_TB_BORDER;
/* draw the text within it */
ui_draw_text_full(render_container_get_ui(),text, x1, y1, text_width, JUSTIFY_LEFT, WRAP_WORD,
ui_draw_text_full(&ui_container,text, x1, y1, text_width, JUSTIFY_LEFT, WRAP_WORD,
DRAW_NORMAL, ARGB_WHITE, ARGB_BLACK, NULL, NULL);
}
@ -201,9 +201,9 @@ static void extra_text_render(running_machine *machine, ui_menu *menu, void *sta
footer = ((footer != NULL) && (footer[0] != '\0')) ? footer : NULL;
if (header != NULL)
extra_text_draw_box(origx1, origx2, origy1, top, header, -1);
extra_text_draw_box(machine->render().ui_container(), origx1, origx2, origy1, top, header, -1);
if (footer != NULL)
extra_text_draw_box(origx1, origx2, origy2, bottom, footer, +1);
extra_text_draw_box(machine->render().ui_container(), origx1, origx2, origy2, bottom, footer, +1);
}
@ -338,7 +338,7 @@ static void menu_file_create_populate(running_machine *machine, ui_menu *menu, v
ui_menu_item_append(menu, "Create", NULL, 0, ITEMREF_CREATE);
/* set up custom render proc */
ui_menu_set_custom_render(menu, file_create_render_extra, ui_get_line_height() + 3.0f * UI_BOX_TB_BORDER, 0);
ui_menu_set_custom_render(menu, file_create_render_extra, ui_get_line_height(*machine) + 3.0f * UI_BOX_TB_BORDER, 0);
}
@ -379,7 +379,7 @@ static int create_new_image(device_image_interface *image, const char *directory
case ENTTYPE_FILE:
/* a file exists here - ask for permission from the user */
child_menu = ui_menu_alloc(image->device().machine, render_container_get_ui(), menu_confirm_save_as, NULL);
child_menu = ui_menu_alloc(image->device().machine, &image->device().machine->render().ui_container(), menu_confirm_save_as, NULL);
child_menustate = (confirm_save_as_menu_state*)ui_menu_alloc_state(child_menu, sizeof(*child_menustate), NULL);
child_menustate->yes = yes;
ui_menu_stack_push(child_menu);
@ -742,7 +742,7 @@ static file_error menu_file_selector_populate(running_machine *machine, ui_menu
ui_menu_set_selection(menu, (void *) selected_entry);
/* set up custom render proc */
ui_menu_set_custom_render(menu, file_selector_render_extra, ui_get_line_height() + 3.0f * UI_BOX_TB_BORDER, 0);
ui_menu_set_custom_render(menu, file_selector_render_extra, ui_get_line_height(*machine) + 3.0f * UI_BOX_TB_BORDER, 0);
done:
if (directory != NULL)
@ -811,13 +811,13 @@ static void menu_file_selector(running_machine *machine, ui_menu *menu, void *pa
case SELECTOR_ENTRY_TYPE_CREATE:
/* create */
child_menu = ui_menu_alloc(machine, render_container_get_ui(), menu_file_create, NULL);
child_menu = ui_menu_alloc(machine, &machine->render().ui_container(), menu_file_create, NULL);
child_menustate = (file_create_menu_state*)ui_menu_alloc_state(child_menu, sizeof(*child_menustate), NULL);
child_menustate->manager_menustate = menustate->manager_menustate;
ui_menu_stack_push(child_menu);
break;
case SELECTOR_ENTRY_TYPE_SOFTWARE_LIST:
child_menu = ui_menu_alloc(machine, render_container_get_ui(), ui_image_menu_software, menustate->manager_menustate->selected_device);
child_menu = ui_menu_alloc(machine, &machine->render().ui_container(), ui_image_menu_software, menustate->manager_menustate->selected_device);
ui_menu_stack_push(child_menu);
break;
case SELECTOR_ENTRY_TYPE_DRIVE:
@ -919,7 +919,7 @@ static void menu_file_manager_populate(running_machine *machine, ui_menu *menu,
}
/* set up custom render proc */
ui_menu_set_custom_render(menu, file_manager_render_extra, 0, ui_get_line_height() + 3.0f * UI_BOX_TB_BORDER);
ui_menu_set_custom_render(menu, file_manager_render_extra, 0, ui_get_line_height(*machine) + 3.0f * UI_BOX_TB_BORDER);
}
@ -988,7 +988,7 @@ void ui_image_menu_file_manager(running_machine *machine, ui_menu *menu, void *p
ui_menu_reset(menu, UI_MENU_RESET_REMEMBER_POSITION);
/* push the menu */
child_menu = ui_menu_alloc(machine, render_container_get_ui(), menu_file_selector, NULL);
child_menu = ui_menu_alloc(machine, &machine->render().ui_container(), menu_file_selector, NULL);
child_menustate = (file_selector_menu_state *)ui_menu_alloc_state(child_menu, sizeof(*child_menustate), NULL);
child_menustate->manager_menustate = menustate;
ui_menu_stack_push(child_menu);

163
src/emu/uimenu.c
View File

@ -80,9 +80,14 @@ enum
enum
{
VIDEO_ITEM_ROTATE = 0x80000000,
VIDEO_ITEM_BACKDROPS,
VIDEO_ITEM_OVERLAYS,
VIDEO_ITEM_BEZELS,
VIDEO_ITEM_ZOOM,
VIDEO_ITEM_VIEW
};
enum
{
CROSSHAIR_ITEM_VIS = 0,
@ -300,7 +305,7 @@ static void menu_select_game_build_driver_list(ui_menu *menu, select_game_state
static void menu_select_game_custom_render(running_machine *machine, ui_menu *menu, void *state, void *selectedref, float top, float bottom, float x, float y, float x2, float y2);
/* menu helpers */
static void menu_render_triangle(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param);
static void menu_render_triangle(bitmap_t &dest, const bitmap_t &source, const rectangle &sbounds, void *param);
static void menu_settings_custom_render_one(render_container *container, float x1, float y1, float x2, float y2, const dip_descriptor *dip, UINT32 selectedmask);
static void menu_settings_custom_render(running_machine *machine, ui_menu *menu, void *state, void *selectedref, float top, float bottom, float x, float y, float x2, float y2);
@ -394,11 +399,11 @@ void ui_menu_init(running_machine *machine)
if (x > 256 - 25) alpha = 0xff * (255 - x) / 25;
*BITMAP_ADDR32(hilight_bitmap, 0, x) = MAKE_ARGB(alpha,0xff,0xff,0xff);
}
hilight_texture = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(hilight_texture, hilight_bitmap, NULL, TEXFORMAT_ARGB32, NULL);
hilight_texture = machine->render().texture_alloc();
hilight_texture->set_bitmap(hilight_bitmap, NULL, TEXFORMAT_ARGB32);
/* create a texture for arrow icons */
arrow_texture = render_texture_alloc(menu_render_triangle, NULL);
arrow_texture = machine->render().texture_alloc(menu_render_triangle);
/* add an exit callback to free memory */
machine->add_notifier(MACHINE_NOTIFY_EXIT, ui_menu_exit);
@ -416,8 +421,8 @@ static void ui_menu_exit(running_machine &machine)
ui_menu_clear_free_list(&machine);
/* free textures */
render_texture_free(hilight_texture);
render_texture_free(arrow_texture);
machine.render().texture_free(hilight_texture);
machine.render().texture_free(arrow_texture);
}
@ -735,9 +740,9 @@ void ui_menu_set_selection(ui_menu *menu, void *selected_itemref)
static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly)
{
float line_height = ui_get_line_height();
float lr_arrow_width = 0.4f * line_height * render_get_ui_aspect();
float ud_arrow_width = line_height * render_get_ui_aspect();
float line_height = ui_get_line_height(*machine);
float lr_arrow_width = 0.4f * line_height * machine->render().ui_aspect();
float ud_arrow_width = line_height * machine->render().ui_aspect();
float gutter_width = lr_arrow_width * 1.3f;
float x1, y1, x2, y2;
@ -763,11 +768,11 @@ static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly
float total_width;
/* compute width of left hand side */
total_width = gutter_width + ui_get_string_width(item->text) + gutter_width;
total_width = gutter_width + ui_get_string_width(*machine, item->text) + gutter_width;
/* add in width of right hand side */
if (item->subtext)
total_width += 2.0f * gutter_width + ui_get_string_width(item->subtext);
total_width += 2.0f * gutter_width + ui_get_string_width(*machine, item->subtext);
/* track the maximum */
if (total_width > visible_width)
@ -828,7 +833,7 @@ static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly
{
mouse_target = ui_input_find_mouse(machine, &mouse_target_x, &mouse_target_y, &mouse_button);
if (mouse_target != NULL)
if (render_target_map_point_container(mouse_target, mouse_target_x, mouse_target_y, menu->container, &mouse_x, &mouse_y))
if (mouse_target->map_point_container(mouse_target_x, mouse_target_y, *menu->container, mouse_x, mouse_y))
mouse_hit = TRUE;
}
@ -874,13 +879,13 @@ static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly
/* if we have some background hilighting to do, add a quad behind everything else */
if (bgcolor != UI_TEXT_BG_COLOR)
render_container_add_quad(menu->container, line_x0, line_y0, line_x1, line_y1, bgcolor, hilight_texture,
menu->container->add_quad(line_x0, line_y0, line_x1, line_y1, bgcolor, hilight_texture,
PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA) | PRIMFLAG_TEXWRAP(TRUE));
/* if we're on the top line, display the up arrow */
if (linenum == 0 && top_line != 0)
{
render_container_add_quad( menu->container,
menu->container->add_quad(
0.5f * (x1 + x2) - 0.5f * ud_arrow_width,
line_y + 0.25f * line_height,
0.5f * (x1 + x2) + 0.5f * ud_arrow_width,
@ -895,7 +900,7 @@ static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly
/* if we're on the bottom line, display the down arrow */
else if (linenum == visible_lines - 1 && itemnum != menu->numitems - 1)
{
render_container_add_quad( menu->container,
menu->container->add_quad(
0.5f * (x1 + x2) - 0.5f * ud_arrow_width,
line_y + 0.25f * line_height,
0.5f * (x1 + x2) + 0.5f * ud_arrow_width,
@ -909,7 +914,7 @@ static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly
/* if we're just a divider, draw a line */
else if (strcmp(itemtext, MENU_SEPARATOR_ITEM) == 0)
render_container_add_line(menu->container, visible_left, line_y + 0.5f * line_height, visible_left + visible_width, line_y + 0.5f * line_height, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
menu->container->add_line(visible_left, line_y + 0.5f * line_height, visible_left + visible_width, line_y + 0.5f * line_height, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
/* if we don't have a subitem, just draw the string centered */
else if (item->subtext == NULL)
@ -931,7 +936,7 @@ static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly
item_width += 2.0f * gutter_width;
/* if the subitem doesn't fit here, display dots */
if (ui_get_string_width(subitem_text) > effective_width - item_width)
if (ui_get_string_width(*machine, subitem_text) > effective_width - item_width)
{
subitem_text = "...";
if (itemnum == menu->selected)
@ -945,7 +950,7 @@ static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly
/* apply arrows */
if (itemnum == menu->selected && (item->flags & MENU_FLAG_LEFT_ARROW))
{
render_container_add_quad( menu->container,
menu->container->add_quad(
effective_left + effective_width - subitem_width - gutter_width,
line_y + 0.1f * line_height,
effective_left + effective_width - subitem_width - gutter_width + lr_arrow_width,
@ -956,7 +961,7 @@ static void ui_menu_draw(running_machine *machine, ui_menu *menu, int customonly
}
if (itemnum == menu->selected && (item->flags & MENU_FLAG_RIGHT_ARROW))
{
render_container_add_quad( menu->container,
menu->container->add_quad(
effective_left + effective_width + gutter_width - lr_arrow_width,
line_y + 0.1f * line_height,
effective_left + effective_width + gutter_width,
@ -1019,8 +1024,8 @@ static void ui_menu_draw_text_box(ui_menu *menu)
{
const char *text = menu->item[0].text;
const char *backtext = menu->item[1].text;
float line_height = ui_get_line_height();
float lr_arrow_width = 0.4f * line_height * render_get_ui_aspect();
float line_height = ui_get_line_height(*menu->machine);
float lr_arrow_width = 0.4f * line_height * menu->machine->render().ui_aspect();
float gutter_width = lr_arrow_width;
float target_width, target_height, prior_width;
float target_x, target_y;
@ -1033,7 +1038,7 @@ static void ui_menu_draw_text_box(ui_menu *menu)
target_height = floor((1.0f - 2.0f * UI_BOX_TB_BORDER) / line_height) * line_height;
/* maximum against "return to prior menu" text */
prior_width = ui_get_string_width(backtext) + 2.0f * gutter_width;
prior_width = ui_get_string_width(*menu->machine, backtext) + 2.0f * gutter_width;
target_width = MAX(target_width, prior_width);
/* determine the target location */
@ -1059,7 +1064,7 @@ static void ui_menu_draw_text_box(ui_menu *menu)
JUSTIFY_LEFT, WRAP_WORD, DRAW_NORMAL, UI_TEXT_COLOR, UI_TEXT_BG_COLOR, NULL, NULL);
/* draw the "return to prior menu" text with a hilight behind it */
render_container_add_quad(menu->container,
menu->container->add_quad(
target_x + 0.5f * UI_LINE_WIDTH,
target_y + target_height - line_height,
target_x + target_width - 0.5f * UI_LINE_WIDTH,
@ -1557,7 +1562,7 @@ static void menu_main_populate(running_machine *machine, ui_menu *menu, void *st
ui_menu_item_append(menu, "Slider Controls", NULL, 0, (void *)menu_sliders);
/* add video options menu */
ui_menu_item_append(menu, "Video Options", NULL, 0, (render_target_get_indexed(1) != NULL) ? (void *)menu_video_targets : (void *)menu_video_options);
ui_menu_item_append(menu, "Video Options", NULL, 0, (machine->render().target_by_index(1) != NULL) ? (void *)menu_video_targets : (void *)menu_video_options);
/* add crosshair options menu */
if (crosshair_get_usage(machine))
@ -2177,8 +2182,8 @@ static void menu_settings_custom_render(running_machine *machine, ui_menu *menu,
static void menu_settings_custom_render_one(render_container *container, float x1, float y1, float x2, float y2, const dip_descriptor *dip, UINT32 selectedmask)
{
float switch_field_width = SINGLE_TOGGLE_SWITCH_FIELD_WIDTH * render_get_ui_aspect();
float switch_width = SINGLE_TOGGLE_SWITCH_WIDTH * render_get_ui_aspect();
float switch_field_width = SINGLE_TOGGLE_SWITCH_FIELD_WIDTH * container->manager().ui_aspect();
float switch_width = SINGLE_TOGGLE_SWITCH_WIDTH * container->manager().ui_aspect();
int numtoggles, toggle;
float switch_toggle_gap;
float y1_off, y1_on;
@ -2194,7 +2199,7 @@ static void menu_settings_custom_render_one(render_container *container, float x
dip->name,
0,
y1 + (DIP_SWITCH_HEIGHT - UI_TARGET_FONT_HEIGHT) / 2,
x1 - ui_get_string_width(" "),
x1 - ui_get_string_width(container->manager().machine(), " "),
JUSTIFY_RIGHT,
WRAP_NEVER,
DRAW_NORMAL,
@ -2223,13 +2228,13 @@ static void menu_settings_custom_render_one(render_container *container, float x
if (dip->mask & (1 << toggle))
{
float innery1 = (dip->state & (1 << toggle)) ? y1_on : y1_off;
render_container_add_rect(container, innerx1, innery1, innerx1 + switch_width, innery1 + SINGLE_TOGGLE_SWITCH_HEIGHT,
container->add_rect(innerx1, innery1, innerx1 + switch_width, innery1 + SINGLE_TOGGLE_SWITCH_HEIGHT,
(selectedmask & (1 << toggle)) ? UI_DIPSW_COLOR : UI_TEXT_COLOR,
PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
else
{
render_container_add_rect(container, innerx1, y1_off, innerx1 + switch_width, y1_on + SINGLE_TOGGLE_SWITCH_HEIGHT,
container->add_rect(innerx1, y1_off, innerx1 + switch_width, y1_on + SINGLE_TOGGLE_SWITCH_HEIGHT,
UI_UNAVAILABLE_COLOR,
PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
}
@ -2871,7 +2876,7 @@ static void menu_sliders_populate(running_machine *machine, ui_menu *menu, int m
break;
}
ui_menu_set_custom_render(menu, menu_sliders_custom_render, 0.0f, 2.0f * ui_get_line_height() + 2.0f * UI_BOX_TB_BORDER);
ui_menu_set_custom_render(menu, menu_sliders_custom_render, 0.0f, 2.0f * ui_get_line_height(*machine) + 2.0f * UI_BOX_TB_BORDER);
}
@ -2886,7 +2891,7 @@ static void menu_sliders_custom_render(running_machine *machine, ui_menu *menu,
if (curslider != NULL)
{
float bar_left, bar_area_top, bar_width, bar_area_height, bar_top, bar_bottom, default_x, current_x;
float line_height = ui_get_line_height();
float line_height = ui_get_line_height(*machine);
float percentage, default_percentage;
astring tempstring;
float text_height;
@ -2929,15 +2934,15 @@ static void menu_sliders_custom_render(running_machine *machine, ui_menu *menu,
current_x = bar_left + bar_width * percentage;
/* fill in the percentage */
render_container_add_rect(menu->container, bar_left, bar_top, current_x, bar_bottom, UI_SLIDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
menu->container->add_rect(bar_left, bar_top, current_x, bar_bottom, UI_SLIDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
/* draw the top and bottom lines */
render_container_add_line(menu->container, bar_left, bar_top, bar_left + bar_width, bar_top, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
render_container_add_line(menu->container, bar_left, bar_bottom, bar_left + bar_width, bar_bottom, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
menu->container->add_line(bar_left, bar_top, bar_left + bar_width, bar_top, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
menu->container->add_line(bar_left, bar_bottom, bar_left + bar_width, bar_bottom, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
/* draw default marker */
render_container_add_line(menu->container, default_x, bar_area_top, default_x, bar_top, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
render_container_add_line(menu->container, default_x, bar_bottom, default_x, bar_area_top + bar_area_height, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
menu->container->add_line(default_x, bar_area_top, default_x, bar_top, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
menu->container->add_line(default_x, bar_bottom, default_x, bar_area_top + bar_area_height, UI_LINE_WIDTH, UI_BORDER_COLOR, PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
/* draw the actual text */
ui_draw_text_full(menu->container, tempstring, x1 + UI_BOX_LR_BORDER, y1 + line_height, x2 - x1 - 2.0f * UI_BOX_LR_BORDER,
@ -2978,7 +2983,7 @@ static void menu_video_targets_populate(running_machine *machine, ui_menu *menu)
/* find the targets */
for (targetnum = 0; ; targetnum++)
{
render_target *target = render_target_get_indexed(targetnum);
render_target *target = machine->render().target_by_index(targetnum);
char buffer[40];
/* stop when we run out */
@ -2999,7 +3004,7 @@ static void menu_video_targets_populate(running_machine *machine, ui_menu *menu)
static void menu_video_options(running_machine *machine, ui_menu *menu, void *parameter, void *state)
{
render_target *target = (parameter != NULL) ? (render_target *)parameter : render_target_get_indexed(0);
render_target *target = (parameter != NULL) ? (render_target *)parameter : machine->render().first_target();
const ui_menu_event *event;
int changed = FALSE;
@ -3018,26 +3023,47 @@ static void menu_video_options(running_machine *machine, ui_menu *menu, void *pa
if (event->iptkey == IPT_UI_LEFT || event->iptkey == IPT_UI_RIGHT)
{
int delta = (event->iptkey == IPT_UI_LEFT) ? ROT270 : ROT90;
render_target_set_orientation(target, orientation_add(delta, render_target_get_orientation(target)));
if (target == render_get_ui_target())
target->set_orientation(orientation_add(delta, target->orientation()));
if (target->is_ui_target())
{
render_container_user_settings settings;
render_container_get_user_settings(menu->container, &settings);
settings.orientation = orientation_add(delta ^ ROT180, settings.orientation);
render_container_set_user_settings(menu->container, &settings);
render_container::user_settings settings;
menu->container->get_user_settings(settings);
settings.m_orientation = orientation_add(delta ^ ROT180, settings.m_orientation);
menu->container->set_user_settings(settings);
}
changed = TRUE;
}
break;
/* layer config bitmasks handle left/right keys the same (toggle) */
case LAYER_CONFIG_ENABLE_BACKDROP:
case LAYER_CONFIG_ENABLE_OVERLAY:
case LAYER_CONFIG_ENABLE_BEZEL:
case LAYER_CONFIG_ZOOM_TO_SCREEN:
case VIDEO_ITEM_BACKDROPS:
if (event->iptkey == IPT_UI_LEFT || event->iptkey == IPT_UI_RIGHT)
{
render_target_set_layer_config(target, render_target_get_layer_config(target) ^ (FPTR)event->itemref);
target->set_backdrops_enabled(!target->backdrops_enabled());
changed = TRUE;
}
break;
case VIDEO_ITEM_OVERLAYS:
if (event->iptkey == IPT_UI_LEFT || event->iptkey == IPT_UI_RIGHT)
{
target->set_overlays_enabled(!target->overlays_enabled());
changed = TRUE;
}
break;
case VIDEO_ITEM_BEZELS:
if (event->iptkey == IPT_UI_LEFT || event->iptkey == IPT_UI_RIGHT)
{
target->set_bezels_enabled(!target->bezels_enabled());
changed = TRUE;
}
break;
case VIDEO_ITEM_ZOOM:
if (event->iptkey == IPT_UI_LEFT || event->iptkey == IPT_UI_RIGHT)
{
target->set_zoom_to_screen(!target->zoom_to_screen());
changed = TRUE;
}
break;
@ -3046,7 +3072,7 @@ static void menu_video_options(running_machine *machine, ui_menu *menu, void *pa
default:
if (event->iptkey == IPT_UI_SELECT && (int)(FPTR)event->itemref >= VIDEO_ITEM_VIEW)
{
render_target_set_view(target, (FPTR)event->itemref - VIDEO_ITEM_VIEW);
target->set_view((FPTR)event->itemref - VIDEO_ITEM_VIEW);
changed = TRUE;
}
break;
@ -3066,7 +3092,6 @@ static void menu_video_options(running_machine *machine, ui_menu *menu, void *pa
static void menu_video_options_populate(running_machine *machine, ui_menu *menu, render_target *target)
{
int layermask = render_target_get_layer_config(target);
const char *subtext = "";
astring tempstring;
int viewnum;
@ -3075,7 +3100,7 @@ static void menu_video_options_populate(running_machine *machine, ui_menu *menu,
/* add items for each view */
for (viewnum = 0; ; viewnum++)
{
const char *name = render_target_get_view_name(target, viewnum);
const char *name = target->view_name(viewnum);
if (name == NULL)
break;
@ -3088,7 +3113,7 @@ static void menu_video_options_populate(running_machine *machine, ui_menu *menu,
ui_menu_item_append(menu, MENU_SEPARATOR_ITEM, NULL, 0, NULL);
/* add a rotate item */
switch (render_target_get_orientation(target))
switch (target->orientation())
{
case ROT0: subtext = "None"; break;
case ROT90: subtext = "CW 90" UTF8_DEGREES; break;
@ -3098,20 +3123,20 @@ static void menu_video_options_populate(running_machine *machine, ui_menu *menu,
ui_menu_item_append(menu, "Rotate", subtext, MENU_FLAG_LEFT_ARROW | MENU_FLAG_RIGHT_ARROW, (void *)VIDEO_ITEM_ROTATE);
/* backdrop item */
enabled = layermask & LAYER_CONFIG_ENABLE_BACKDROP;
ui_menu_item_append(menu, "Backdrops", enabled ? "Enabled" : "Disabled", enabled ? MENU_FLAG_LEFT_ARROW : MENU_FLAG_RIGHT_ARROW, (void *)LAYER_CONFIG_ENABLE_BACKDROP);
enabled = target->backdrops_enabled();
ui_menu_item_append(menu, "Backdrops", enabled ? "Enabled" : "Disabled", enabled ? MENU_FLAG_LEFT_ARROW : MENU_FLAG_RIGHT_ARROW, (void *)VIDEO_ITEM_BACKDROPS);
/* overlay item */
enabled = layermask & LAYER_CONFIG_ENABLE_OVERLAY;
ui_menu_item_append(menu, "Overlays", enabled ? "Enabled" : "Disabled", enabled ? MENU_FLAG_LEFT_ARROW : MENU_FLAG_RIGHT_ARROW, (void *)LAYER_CONFIG_ENABLE_OVERLAY);
enabled = target->overlays_enabled();
ui_menu_item_append(menu, "Overlays", enabled ? "Enabled" : "Disabled", enabled ? MENU_FLAG_LEFT_ARROW : MENU_FLAG_RIGHT_ARROW, (void *)VIDEO_ITEM_OVERLAYS);
/* bezel item */
enabled = layermask & LAYER_CONFIG_ENABLE_BEZEL;
ui_menu_item_append(menu, "Bezels", enabled ? "Enabled" : "Disabled", enabled ? MENU_FLAG_LEFT_ARROW : MENU_FLAG_RIGHT_ARROW, (void *)LAYER_CONFIG_ENABLE_BEZEL);
enabled = target->bezels_enabled();
ui_menu_item_append(menu, "Bezels", enabled ? "Enabled" : "Disabled", enabled ? MENU_FLAG_LEFT_ARROW : MENU_FLAG_RIGHT_ARROW, (void *)VIDEO_ITEM_BEZELS);
/* cropping */
enabled = layermask & LAYER_CONFIG_ZOOM_TO_SCREEN;
ui_menu_item_append(menu, "View", enabled ? "Cropped" : "Full", enabled ? MENU_FLAG_RIGHT_ARROW : MENU_FLAG_LEFT_ARROW, (void *)LAYER_CONFIG_ZOOM_TO_SCREEN);
enabled = target->zoom_to_screen();
ui_menu_item_append(menu, "View", enabled ? "Cropped" : "Full", enabled ? MENU_FLAG_RIGHT_ARROW : MENU_FLAG_LEFT_ARROW, (void *)VIDEO_ITEM_ZOOM);
}
@ -3556,7 +3581,7 @@ static void menu_select_game_populate(running_machine *machine, ui_menu *menu, s
}
/* configure the custom rendering */
ui_menu_set_custom_render(menu, menu_select_game_custom_render, ui_get_line_height() + 3.0f * UI_BOX_TB_BORDER, 4.0f * ui_get_line_height() + 3.0f * UI_BOX_TB_BORDER);
ui_menu_set_custom_render(menu, menu_select_game_custom_render, ui_get_line_height(*machine) + 3.0f * UI_BOX_TB_BORDER, 4.0f * ui_get_line_height(*machine) + 3.0f * UI_BOX_TB_BORDER);
}
@ -3787,7 +3812,7 @@ static void menu_select_game_custom_render(running_machine *machine, ui_menu *me
{
ui_draw_text_full(menu->container, &tempbuf[line][0], x1, y1, x2 - x1, JUSTIFY_CENTER, WRAP_TRUNCATE,
DRAW_NORMAL, UI_TEXT_COLOR, UI_TEXT_BG_COLOR, NULL, NULL);
y1 += ui_get_line_height();
y1 += ui_get_line_height(*machine);
}
}
@ -3803,23 +3828,23 @@ static void menu_select_game_custom_render(running_machine *machine, ui_menu *me
indicators
-------------------------------------------------*/
static void menu_render_triangle(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param)
static void menu_render_triangle(bitmap_t &dest, const bitmap_t &source, const rectangle &sbounds, void *param)
{
int halfwidth = dest->width / 2;
int height = dest->height;
int halfwidth = dest.width / 2;
int height = dest.height;
int x, y;
/* start with all-transparent */
bitmap_fill(dest, NULL, MAKE_ARGB(0x00,0x00,0x00,0x00));
bitmap_fill(&dest, NULL, MAKE_ARGB(0x00,0x00,0x00,0x00));
/* render from the tip to the bottom */
for (y = 0; y < height; y++)
{
int linewidth = (y * (halfwidth - 1) + (height / 2)) * 255 * 2 / height;
UINT32 *target = BITMAP_ADDR32(dest, y, halfwidth);
UINT32 *target = BITMAP_ADDR32(&dest, y, halfwidth);
/* don't antialias if height < 12 */
if (dest->height < 12)
if (dest.height < 12)
{
int pixels = (linewidth + 254) / 255;
if (pixels % 2 == 0) pixels++;

94
src/emu/video.c
View File

@ -193,7 +193,7 @@ static void video_mng_record_frame(running_machine *machine);
static void video_avi_record_frame(running_machine *machine);
/* software rendering */
static void rgb888_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void rgb888_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
@ -311,18 +311,16 @@ void video_init(running_machine *machine)
/* the native target is hard-coded to our internal layout and has all options disabled */
if (global.snap_native)
{
global.snap_target = render_target_alloc(machine, layout_snap, RENDER_CREATE_SINGLE_FILE | RENDER_CREATE_HIDDEN);
assert(global.snap_target != NULL);
render_target_set_layer_config(global.snap_target, 0);
global.snap_target = machine->render().target_alloc(layout_snap, RENDER_CREATE_SINGLE_FILE | RENDER_CREATE_HIDDEN);
global.snap_target->set_layer_config(0);
}
/* other targets select the specified view and turn off effects */
else
{
global.snap_target = render_target_alloc(machine, NULL, RENDER_CREATE_HIDDEN);
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_layer_config(global.snap_target, render_target_get_layer_config(global.snap_target) & ~LAYER_CONFIG_ENABLE_SCREEN_OVERLAY);
global.snap_target = machine->render().target_alloc(NULL, RENDER_CREATE_HIDDEN);
global.snap_target->set_view(video_get_view_for_target(machine, global.snap_target, viewname, 0, 1));
global.snap_target->set_screen_overlay_enabled(false);
}
/* extract snap resolution if present */
@ -364,8 +362,7 @@ static void video_exit(running_machine &machine)
gfx_element_free(machine.gfx[i]);
/* free the snapshot target */
if (global.snap_target != NULL)
render_target_free(global.snap_target);
machine.render().target_free(global.snap_target);
if (global.snap_bitmap != NULL)
global_free(global.snap_bitmap);
@ -455,7 +452,7 @@ void video_frame_update(running_machine *machine, int debug)
}
/* draw the user interface */
ui_update_and_render(machine, render_container_get_ui());
ui_update_and_render(machine, &machine->render().ui_container());
/* update the internal render debugger */
debugint_update_during_game(machine);
@ -991,7 +988,7 @@ static void update_refresh_speed(running_machine *machine)
/* only do this if the refreshspeed option is used */
if (options_get_bool(machine->options(), OPTION_REFRESHSPEED))
{
float minrefresh = render_get_max_update_rate();
float minrefresh = machine->render().max_update_rate();
if (minrefresh != 0)
{
attoseconds_t min_frame_period = ATTOSECONDS_PER_SECOND;
@ -1156,7 +1153,7 @@ void video_save_active_screen_snapshots(running_machine *machine)
{
/* write one snapshot per visible screen */
for (screen_device *screen = screen_first(*machine); screen != NULL; screen = screen_next(screen))
if (render_is_live_screen(screen))
if (machine->render().is_live(*screen))
{
file_error filerr = mame_fopen_next(machine, SEARCHPATH_SCREENSHOT, "png", &fp);
if (filerr == FILERR_NONE)
@ -1188,7 +1185,6 @@ void video_save_active_screen_snapshots(running_machine *machine)
static void create_snapshot_bitmap(device_t *screen)
{
const render_primitive_list *primlist;
INT32 width, height;
int view_index;
@ -1197,15 +1193,15 @@ static void create_snapshot_bitmap(device_t *screen)
{
view_index = screen->machine->m_devicelist.index(SCREEN, screen->tag());
assert(view_index != -1);
render_target_set_view(global.snap_target, view_index);
global.snap_target->set_view(view_index);
}
/* get the minimum width/height and set it on the target */
width = global.snap_width;
height = global.snap_height;
if (width == 0 || height == 0)
render_target_get_minimum_size(global.snap_target, &width, &height);
render_target_set_bounds(global.snap_target, width, height, 0);
global.snap_target->compute_minimum_size(width, height);
global.snap_target->set_bounds(width, height);
/* if we don't have a bitmap, or if it's not the right size, allocate a new one */
if (global.snap_bitmap == NULL || width != global.snap_bitmap->width || height != global.snap_bitmap->height)
@ -1217,10 +1213,10 @@ static void create_snapshot_bitmap(device_t *screen)
}
/* render the screen there */
primlist = render_target_get_primitives(global.snap_target);
osd_lock_acquire(primlist->lock);
rgb888_draw_primitives(primlist->head, global.snap_bitmap->base, width, height, global.snap_bitmap->rowpixels);
osd_lock_release(primlist->lock);
render_primitive_list &primlist = global.snap_target->get_primitives();
primlist.acquire_lock();
rgb888_draw_primitives(primlist, global.snap_bitmap->base, width, height, global.snap_bitmap->rowpixels);
primlist.release_lock();
}
@ -1586,7 +1582,7 @@ int video_get_view_for_target(running_machine *machine, render_target *target, c
/* scan for a matching view name */
for (viewindex = 0; ; viewindex++)
{
const char *name = render_target_get_view_name(target, viewindex);
const char *name = target->view_name(viewindex);
/* stop scanning when we hit NULL */
if (name == NULL)
@ -1610,7 +1606,7 @@ int video_get_view_for_target(running_machine *machine, render_target *target, c
/* find the first view with this screen and this screen only */
for (viewindex = 0; ; viewindex++)
{
UINT32 viewscreens = render_target_get_view_screens(target, viewindex);
UINT32 viewscreens = target->view_screens(viewindex);
if (viewscreens == (1 << targetindex))
break;
if (viewscreens == 0)
@ -1626,7 +1622,7 @@ int video_get_view_for_target(running_machine *machine, render_target *target, c
{
for (viewindex = 0; ; viewindex++)
{
UINT32 viewscreens = render_target_get_view_screens(target, viewindex);
UINT32 viewscreens = target->view_screens(viewindex);
if (viewscreens == (1 << scrcount) - 1)
break;
if (viewscreens == 0)
@ -1636,7 +1632,7 @@ int video_get_view_for_target(running_machine *machine, render_target *target, c
}
/* make sure it's a valid view */
if (render_target_get_view_name(target, viewindex) == NULL)
if (target->view_name(viewindex) == NULL)
viewindex = 0;
return viewindex;
@ -1897,6 +1893,7 @@ bool screen_device_config::device_validity_check(const game_driver &driver) cons
screen_device::screen_device(running_machine &_machine, const screen_device_config &config)
: device_t(_machine, config),
m_config(config),
m_container(NULL),
m_width(m_config.m_width),
m_height(m_config.m_height),
m_visarea(m_config.m_visarea),
@ -1930,10 +1927,8 @@ screen_device::screen_device(running_machine &_machine, const screen_device_conf
screen_device::~screen_device()
{
if (m_texture[0] != NULL)
render_texture_free(m_texture[0]);
if (m_texture[1] != NULL)
render_texture_free(m_texture[1]);
m_machine.render().texture_free(m_texture[0]);
m_machine.render().texture_free(m_texture[1]);
if (m_burnin != NULL)
finalize_burnin();
}
@ -1946,17 +1941,16 @@ screen_device::~screen_device()
void screen_device::device_start()
{
// get and validate that the container for this screen exists
render_container *container = render_container_get_screen(this);
assert(container != NULL);
m_container = m_machine.render().container_for_screen(this);
// configure the default cliparea
render_container_user_settings settings;
render_container_get_user_settings(container, &settings);
settings.xoffset = m_config.m_xoffset;
settings.yoffset = m_config.m_yoffset;
settings.xscale = m_config.m_xscale;
settings.yscale = m_config.m_yscale;
render_container_set_user_settings(container, &settings);
render_container::user_settings settings;
m_container->get_user_settings(settings);
settings.m_xoffset = m_config.m_xoffset;
settings.m_yoffset = m_config.m_yoffset;
settings.m_xscale = m_config.m_xscale;
settings.m_yscale = m_config.m_yscale;
m_container->set_user_settings(settings);
// allocate the VBLANK timers
m_vblank_begin_timer = timer_alloc(machine, static_vblank_begin_callback, (void *)this);
@ -2096,10 +2090,8 @@ void screen_device::realloc_screen_bitmaps()
if (m_width > curwidth || m_height > curheight)
{
// free what we have currently
if (m_texture[0] != NULL)
render_texture_free(m_texture[0]);
if (m_texture[1] != NULL)
render_texture_free(m_texture[1]);
global_free(m_texture[0]);
global_free(m_texture[1]);
if (m_bitmap[0] != NULL)
auto_free(machine, m_bitmap[0]);
if (m_bitmap[1] != NULL)
@ -2126,10 +2118,10 @@ void screen_device::realloc_screen_bitmaps()
bitmap_set_palette(m_bitmap[1], machine->palette);
// allocate textures
m_texture[0] = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(m_texture[0], m_bitmap[0], &m_visarea, m_texture_format, palette);
m_texture[1] = render_texture_alloc(NULL, NULL);
render_texture_set_bitmap(m_texture[1], m_bitmap[1], &m_visarea, m_texture_format, palette);
m_texture[0] = m_machine.render().texture_alloc();
m_texture[0]->set_bitmap(m_bitmap[0], &m_visarea, m_texture_format, palette);
m_texture[1] = m_machine.render().texture_alloc();
m_texture[1]->set_bitmap(m_bitmap[1], &m_visarea, m_texture_format, palette);
}
}
@ -2180,7 +2172,7 @@ bool screen_device::update_partial(int scanline)
}
// skip if this screen is not visible anywhere
if (!render_is_live_screen(this))
if (!m_machine.render().is_live(*this))
{
LOG_PARTIAL_UPDATES(("skipped because screen not live\n"));
return FALSE;
@ -2460,7 +2452,7 @@ void screen_device::scanline_update_callback(int scanline)
bool screen_device::update_quads()
{
// only update if live
if (render_is_live_screen(this))
if (m_machine.render().is_live(*this))
{
// only update if empty and not a vector game; otherwise assume the driver did it directly
if (m_config.m_type != SCREEN_TYPE_VECTOR && (machine->config->m_video_attributes & VIDEO_SELF_RENDER) == 0)
@ -2473,15 +2465,15 @@ bool screen_device::update_quads()
fixedvis.max_y++;
palette_t *palette = (m_texture_format == TEXFORMAT_PALETTE16) ? machine->palette : NULL;
render_texture_set_bitmap(m_texture[m_curbitmap], m_bitmap[m_curbitmap], &fixedvis, m_texture_format, palette);
m_texture[m_curbitmap]->set_bitmap(m_bitmap[m_curbitmap], &fixedvis, m_texture_format, palette);
m_curtexture = m_curbitmap;
m_curbitmap = 1 - m_curbitmap;
}
// create an empty container with a single quad
render_container_empty(render_container_get_screen(this));
render_screen_add_quad(this, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), m_texture[m_curtexture], PRIMFLAG_BLENDMODE(BLENDMODE_NONE) | PRIMFLAG_SCREENTEX(1));
m_container->empty();
m_container->add_quad(0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), m_texture[m_curtexture], PRIMFLAG_BLENDMODE(BLENDMODE_NONE) | PRIMFLAG_SCREENTEX(1));
}
}

4
src/emu/video.h
View File

@ -72,7 +72,7 @@ enum screen_type_enum
// forward references
class render_target;
struct render_texture;
class render_texture;
class screen_device;
@ -155,6 +155,7 @@ public:
int height() const { return m_height; }
const rectangle &visible_area() const { return m_visarea; }
bitmap_format format() const { return m_config.m_format; }
render_container &container() const { assert(m_container != NULL); return *m_container; }
// dynamic configuration
void configure(int width, int height, const rectangle &visarea, attoseconds_t frame_period);
@ -218,6 +219,7 @@ private:
// internal state
const screen_device_config &m_config;
render_container * m_container; // pointer to our container
// dimensions
int m_width; // current width (HTOTAL)

6
src/emu/video/vector.c
View File

@ -269,8 +269,8 @@ VIDEO_UPDATE( vector )
curpoint = vector_list;
render_container_empty(render_container_get_screen(screen));
render_screen_add_rect(screen, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0x00,0x00,0x00), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
screen->container().empty();
screen->container().add_rect(0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0x00,0x00,0x00), PRIMFLAG_BLENDMODE(BLENDMODE_ALPHA));
clip.x0 = clip.y0 = 0.0f;
clip.x1 = clip.y1 = 1.0f;
@ -300,7 +300,7 @@ VIDEO_UPDATE( vector )
if (curpoint->intensity != 0)
if (!render_clip_line(&coords, &clip))
render_screen_add_line(screen, coords.x0, coords.y0, coords.x1, coords.y1,
screen->container().add_line(coords.x0, coords.y0, coords.x1, coords.y1,
beam_width * (1.0f / (float)VECTOR_WIDTH_DENOM),
(curpoint->intensity << 24) | (curpoint->col & 0xffffff),
flags);

6
src/mame/drivers/mazerbla.c
View File

@ -215,7 +215,7 @@ VIDEO_UPDATE( test_vcu )
if (dbg_info)
{
sprintf(buf,"I-info, G-gfx, C-color, V-vbank, 1-4 enable planes");
ui_draw_text(buf, 10, 0 * ui_get_line_height());
ui_draw_text(buf, 10, 0 * ui_get_line_height(*screen->machine));
sprintf(buf,"g:%1i c:%1i v:%1i vbk=%1i planes=%1i%1i%1i%1i ", dbg_gfx_e&1, dbg_clr_e&1, dbg_vbank, vbank&1,
planes_enabled[0],
@ -223,7 +223,7 @@ VIDEO_UPDATE( test_vcu )
planes_enabled[2],
planes_enabled[3] );
ui_draw_text(buf, 10, 1 * ui_get_line_height());
ui_draw_text(buf, 10, 1 * ui_get_line_height(*screen->machine));
if (dbg_lookup!=4)
{
@ -238,7 +238,7 @@ VIDEO_UPDATE( test_vcu )
{
sprintf(buf + strlen(buf), "%02x ", lookup_ram[lookup_offs + x + y * 16]);
}
ui_draw_text(buf, 0, (2 + y) * ui_get_line_height());
ui_draw_text(buf, 0, (2 + y) * ui_get_line_height(*screen->machine));
}
}
}

8
src/mame/machine/fddebug.c
View File

@ -676,8 +676,8 @@ void fd1094_regenerate_key(running_machine *machine)
(*key_changed)(machine);
/* force all memory and disassembly views to update */
machine->m_debug_view->update_all(DVT_MEMORY);
machine->m_debug_view->update_all(DVT_DISASSEMBLY);
machine->debug_view().update_all(DVT_MEMORY);
machine->debug_view().update_all(DVT_DISASSEMBLY);
/* reset keydirty */
keydirty = FALSE;
@ -1014,8 +1014,8 @@ static void execute_fdstate(running_machine *machine, int ref, int params, const
return;
fd1094_set_state(keyregion, newstate);
fd1094_regenerate_key(machine);
machine->m_debug_view->update_all(DVT_MEMORY);
machine->m_debug_view->update_all(DVT_DISASSEMBLY);
machine->debug_view().update_all(DVT_MEMORY);
machine->debug_view().update_all(DVT_DISASSEMBLY);
}
/* 0 parameters displays the current state */

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

@ -1077,7 +1077,7 @@ void deco16ic_print_debug_info(running_device *device, bitmap_t *bitmap)
sprintf(&buf[strlen(buf)],"%04X", deco16ic->priority);
ui_draw_text(render_container_get_ui(), buf, 60, 40);
ui_draw_text(&device->machine->render().ui_container(), buf, 60, 40);
}
/*****************************************************************************************/

4
src/mame/video/ssv.c
View File

@ -948,7 +948,7 @@ static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const recta
if (input_code_pressed(machine, KEYCODE_Z)) /* Display some info on each sprite */
{ char buf[30];
sprintf(buf, "%02X",/*(s2[2] & ~0x3ff)>>8*/mode>>8);
ui_draw_text(render_container_get_ui(), buf, sx, sy);
ui_draw_text(&machine->render().ui_container(), buf, sx, sy);
}
#endif
@ -1129,7 +1129,7 @@ static void gdfs_draw_zooming_sprites(running_machine *machine, bitmap_t *bitmap
{
char buf[10];
sprintf(buf, "%X",size);
ui_draw_text(render_container_get_ui(), buf, sx / 0x10000, sy / 0x10000);
ui_draw_text(&machine->render().ui_container(), buf, sx / 0x10000, sy / 0x10000);
}
#endif
} /* single-sprites */

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

@ -411,7 +411,7 @@ static int (**dpix_sp[9])(UINT32 s_pix);
/******************************************************************************/
static void print_debug_info(bitmap_t *bitmap)
static void print_debug_info(running_machine *machine, bitmap_t *bitmap)
{
int l[16];
char buf[64*16];
@ -480,7 +480,7 @@ static void print_debug_info(bitmap_t *bitmap)
l[3]=f3_line_ram[0x15e0]&0xffff;
bufptr += sprintf(bufptr,"5000: %04x %04x %04x %04x\n",l[0],l[1],l[2],l[3]);
ui_draw_text(render_container_get_ui(), buf, 60, 40);
ui_draw_text(&machine->render().ui_container(), buf, 60, 40);
}
/******************************************************************************/
@ -3292,6 +3292,6 @@ VIDEO_UPDATE( f3 )
scanline_draw(screen->machine, bitmap,cliprect);
if (VERBOSE)
print_debug_info(bitmap);
print_debug_info(screen->machine, bitmap);
return 0;
}

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

@ -124,7 +124,6 @@ static UINT8 *tx1_obj_bmp;
static UINT8 *tx1_rod_bmp;
static bitmap_t *tx1_bitmap;
static render_texture *tx1_texture;
/***************************************************************************
@ -1122,7 +1121,6 @@ VIDEO_START( tx1 )
{
/* Allocate a large bitmap that covers the three screens */
tx1_bitmap = auto_bitmap_alloc(machine, 768, 256, BITMAP_FORMAT_INDEXED16);
tx1_texture = render_texture_alloc(NULL, NULL);
/* Allocate some bitmaps */
tx1_chr_bmp = auto_alloc_array(machine, UINT8, 256 * 3 * 240);

10
src/osd/osdmini/minimain.c
View File

@ -105,9 +105,7 @@ int main(int argc, char *argv[])
void osd_init(running_machine *machine)
{
// initialize the video system by allocating a rendering target
our_target = render_target_alloc(machine, NULL, 0);
if (our_target == NULL)
fatalerror("Error creating render target");
our_target = machine->render().target_alloc();
// nothing yet to do to initialize sound, since we don't have any
// sound updates are handled by osd_update_audio_stream() below
@ -164,13 +162,13 @@ void osd_update(running_machine *machine, int skip_redraw)
int minwidth, minheight;
// get the minimum width/height for the current layout
render_target_get_minimum_size(our_target, &minwidth, &minheight);
our_target->compute_minimum_size(minwidth, minheight);
// make that the size of our target
render_target_set_bounds(our_target, minwidth, minheight, 0);
our_target->render_target_set_bounds(minwidth, minheight);
// get the list of primitives for the target at the current size
primlist = render_target_get_primitives(our_target);
primlist = our_target->get_primitives();
// lock them, and then render them
osd_lock_acquire(primlist->lock);

8
src/osd/sdl/draw13.c
View File

@ -686,8 +686,8 @@ static const render_primitive_list *draw13_window_get_primitives(sdl_window_info
{
sdlwindow_blit_surface_size(window, window->monitor->center_width, window->monitor->center_height);
}
render_target_set_bounds(window->target, window->blitwidth, window->blitheight, sdlvideo_monitor_get_aspect(window->monitor));
return render_target_get_primitives(window->target);
window->target->set_bounds(window->blitwidth, window->blitheight, sdlvideo_monitor_get_aspect(window->monitor));
return window->target->get_primitives();
}
//============================================================
@ -758,7 +758,7 @@ static int draw13_window_draw(sdl_window_info *window, UINT32 dc, int update)
switch (prim->type)
{
case RENDER_PRIMITIVE_LINE:
case render_primitive::LINE:
sr = (int)(255.0f * prim->color.r);
sg = (int)(255.0f * prim->color.g);
sb = (int)(255.0f * prim->color.b);
@ -769,7 +769,7 @@ static int draw13_window_draw(sdl_window_info *window, UINT32 dc, int update)
SDL_RenderDrawLine(prim->bounds.x0 + hofs, prim->bounds.y0 + vofs,
prim->bounds.x1 + hofs, prim->bounds.y1 + vofs);
break;
case RENDER_PRIMITIVE_QUAD:
case render_primitive::QUAD:
texture = texture_update(window, prim);
if (texture)
blit_pixels += (texture->rawheight * texture->rawwidth);

33
src/osd/sdl/drawogl.c
View File

@ -349,7 +349,7 @@ static int drawogl_window_create(sdl_window_info *window, int width, int height)
static void drawogl_window_resize(sdl_window_info *window, int width, int height);
static void drawogl_window_destroy(sdl_window_info *window);
static int drawogl_window_draw(sdl_window_info *window, UINT32 dc, int update);
static const render_primitive_list *drawogl_window_get_primitives(sdl_window_info *window);
static render_primitive_list &drawogl_window_get_primitives(sdl_window_info *window);
static void drawogl_destroy_all_textures(sdl_window_info *window);
static void drawogl_window_clear(sdl_window_info *window);
static int drawogl_xy_to_render_target(sdl_window_info *window, int x, int y, int *xt, int *yt);
@ -837,7 +837,7 @@ static int drawogl_xy_to_render_target(sdl_window_info *window, int x, int y, in
// drawogl_window_get_primitives
//============================================================
static const render_primitive_list *drawogl_window_get_primitives(sdl_window_info *window)
static render_primitive_list &drawogl_window_get_primitives(sdl_window_info *window)
{
if ((!window->fullscreen) || (video_config.switchres))
{
@ -847,8 +847,8 @@ static const render_primitive_list *drawogl_window_get_primitives(sdl_window_inf
{
sdlwindow_blit_surface_size(window, window->monitor->center_width, window->monitor->center_height);
}
render_target_set_bounds(window->target, window->blitwidth, window->blitheight, sdlvideo_monitor_get_aspect(window->monitor));
return render_target_get_primitives(window->target);
window->target->set_bounds(window->blitwidth, window->blitheight, sdlvideo_monitor_get_aspect(window->monitor));
return window->target->get_primitives();
}
//============================================================
@ -1324,10 +1324,10 @@ static int drawogl_window_draw(sdl_window_info *window, UINT32 dc, int update)
sdl->last_hofs = hofs;
sdl->last_vofs = vofs;
osd_lock_acquire(window->primlist->lock);
window->primlist->acquire_lock();
// now draw
for (prim = window->primlist->head; prim != NULL; prim = prim->next)
for (prim = window->primlist->first(); prim != NULL; prim = prim->next())
{
int i;
@ -1337,7 +1337,7 @@ static int drawogl_window_draw(sdl_window_info *window, UINT32 dc, int update)
* Try to stay in one Begin/End block as long as possible,
* since entering and leaving one is most expensive..
*/
case RENDER_PRIMITIVE_LINE:
case render_primitive::LINE:
#if !USE_WIN32_STYLE_LINES
// check if it's really a point
if (((prim->bounds.x1 - prim->bounds.x0) == 0) && ((prim->bounds.y1 - prim->bounds.y0) == 0))
@ -1465,7 +1465,7 @@ static int drawogl_window_draw(sdl_window_info *window, UINT32 dc, int update)
#endif
break;
case RENDER_PRIMITIVE_QUAD:
case render_primitive::QUAD:
if(pendingPrimitive!=GL_NO_PRIMITIVE)
{
@ -1531,6 +1531,9 @@ static int drawogl_window_draw(sdl_window_info *window, UINT32 dc, int update)
texture=NULL;
}
break;
default:
throw emu_fatalerror("Unexpected render_primitive type");
}
}
@ -1540,7 +1543,7 @@ static int drawogl_window_draw(sdl_window_info *window, UINT32 dc, int update)
pendingPrimitive=GL_NO_PRIMITIVE;
}
osd_lock_release(window->primlist->lock);
window->primlist->release_lock();
sdl->init_context = 0;
#if (!SDL_VERSION_ATLEAST(1,3,0))
@ -2945,7 +2948,7 @@ static void texture_shader_update(sdl_window_info *window, texture_info *texture
{
if (scrnum == window->start_viewscreen)
{
container = render_container_get_screen(screen);
container = &screen->container();
}
scrnum++;
@ -2953,8 +2956,8 @@ static void texture_shader_update(sdl_window_info *window, texture_info *texture
if (container!=NULL)
{
render_container_user_settings settings;
render_container_get_user_settings(container, &settings);
render_container::user_settings settings;
container->get_user_settings(settings);
//FIXME: Intended behaviour
#if 1
vid_attributes[0] = options_get_float(window->machine->options(), OPTION_GAMMA);
@ -3128,10 +3131,10 @@ static void drawogl_destroy_all_textures(sdl_window_info *window)
SDL_GL_MakeCurrent(window->sdl_window, sdl->gl_context_id);
#endif
if(window->primlist && window->primlist->lock)
if(window->primlist)
{
lock=TRUE;
osd_lock_acquire(window->primlist->lock);
window->primlist->acquire_lock();
}
glFinish();
@ -3210,7 +3213,7 @@ static void drawogl_destroy_all_textures(sdl_window_info *window)
sdl->initialized = 0;
if (lock)
osd_lock_release(window->primlist->lock);
window->primlist->release_lock();
}
//============================================================

40
src/osd/sdl/drawsdl.c
View File

@ -102,7 +102,7 @@ static void drawsdl_attach(sdl_draw_info *info, sdl_window_info *window);
static int drawsdl_window_create(sdl_window_info *window, int width, int height);
static void drawsdl_window_resize(sdl_window_info *window, int width, int height);
static void drawsdl_window_destroy(sdl_window_info *window);
static const render_primitive_list *drawsdl_window_get_primitives(sdl_window_info *window);
static render_primitive_list &drawsdl_window_get_primitives(sdl_window_info *window);
static int drawsdl_window_draw(sdl_window_info *window, UINT32 dc, int update);
static void drawsdl_destroy_all_textures(sdl_window_info *window);
static void drawsdl_window_clear(sdl_window_info *window);
@ -113,11 +113,11 @@ static void setup_texture(sdl_window_info *window, int tempwidth, int tempheight
#endif
// soft rendering
static void drawsdl_rgb888_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_bgr888_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_bgra888_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_rgb565_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_rgb555_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_rgb888_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_bgr888_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_bgra888_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_rgb565_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawsdl_rgb555_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
// YUV overlays
@ -265,7 +265,7 @@ static void setup_texture(sdl_window_info *window, int tempwidth, int tempheight
if (sdl_sm->is_scale)
{
render_target_get_minimum_size(window->target, &sdl->hw_scale_width, &sdl->hw_scale_height);
window->target->compute_minimum_size(sdl->hw_scale_width, sdl->hw_scale_height);
if (video_config.prescale)
{
sdl->hw_scale_width *= video_config.prescale;
@ -308,7 +308,7 @@ static void yuv_overlay_init(sdl_window_info *window)
const sdl_scale_mode *sdl_sm = sdl->scale_mode;
int minimum_width, minimum_height;
render_target_get_minimum_size(window->target, &minimum_width, &minimum_height);
window->target->compute_minimum_size(minimum_width, minimum_height);
if (video_config.prescale)
{
@ -615,7 +615,7 @@ static int drawsdl_xy_to_render_target(sdl_window_info *window, int x, int y, in
// drawsdl_window_get_primitives
//============================================================
static const render_primitive_list *drawsdl_window_get_primitives(sdl_window_info *window)
static render_primitive_list &drawsdl_window_get_primitives(sdl_window_info *window)
{
sdl_info *sdl = (sdl_info *) window->dxdata;
@ -628,10 +628,10 @@ static const render_primitive_list *drawsdl_window_get_primitives(sdl_window_inf
sdlwindow_blit_surface_size(window, window->monitor->center_width, window->monitor->center_height);
}
if (!sdl->scale_mode->is_scale)
render_target_set_bounds(window->target, window->blitwidth, window->blitheight, sdlvideo_monitor_get_aspect(window->monitor));
window->target->set_bounds(window->blitwidth, window->blitheight, sdlvideo_monitor_get_aspect(window->monitor));
else
render_target_set_bounds(window->target, sdl->hw_scale_width, sdl->hw_scale_height, 0);
return render_target_get_primitives(window->target);
window->target->set_bounds(sdl->hw_scale_width, sdl->hw_scale_height);
return window->target->get_primitives();
}
//============================================================
@ -768,7 +768,7 @@ static int drawsdl_window_draw(sdl_window_info *window, UINT32 dc, int update)
sdl->last_hofs = hofs;
sdl->last_vofs = vofs;
osd_lock_acquire(window->primlist->lock);
window->primlist->acquire_lock();
// render to it
if (!sdl->scale_mode->is_yuv)
@ -791,23 +791,23 @@ static int drawsdl_window_draw(sdl_window_info *window, UINT32 dc, int update)
switch (rmask)
{
case 0x0000ff00:
drawsdl_bgra888_draw_primitives(window->primlist->head, surfptr, mamewidth, mameheight, pitch / 4);
drawsdl_bgra888_draw_primitives(*window->primlist, surfptr, mamewidth, mameheight, pitch / 4);
break;
case 0x00ff0000:
drawsdl_rgb888_draw_primitives(window->primlist->head, surfptr, mamewidth, mameheight, pitch / 4);
drawsdl_rgb888_draw_primitives(*window->primlist, surfptr, mamewidth, mameheight, pitch / 4);
break;
case 0x000000ff:
drawsdl_bgr888_draw_primitives(window->primlist->head, surfptr, mamewidth, mameheight, pitch / 4);
drawsdl_bgr888_draw_primitives(*window->primlist, surfptr, mamewidth, mameheight, pitch / 4);
break;
case 0xf800:
drawsdl_rgb565_draw_primitives(window->primlist->head, surfptr, mamewidth, mameheight, pitch / 2);
drawsdl_rgb565_draw_primitives(*window->primlist, surfptr, mamewidth, mameheight, pitch / 2);
break;
case 0x7c00:
drawsdl_rgb555_draw_primitives(window->primlist->head, surfptr, mamewidth, mameheight, pitch / 2);
drawsdl_rgb555_draw_primitives(*window->primlist, surfptr, mamewidth, mameheight, pitch / 2);
break;
default:
@ -819,11 +819,11 @@ static int drawsdl_window_draw(sdl_window_info *window, UINT32 dc, int update)
{
assert (sdl->yuv_bitmap != NULL);
assert (surfptr != NULL);
drawsdl_rgb555_draw_primitives(window->primlist->head, sdl->yuv_bitmap, sdl->hw_scale_width, sdl->hw_scale_height, sdl->hw_scale_width);
drawsdl_rgb555_draw_primitives(*window->primlist, sdl->yuv_bitmap, sdl->hw_scale_width, sdl->hw_scale_height, sdl->hw_scale_width);
sdl->scale_mode->yuv_blit((UINT16 *)sdl->yuv_bitmap, sdl, surfptr, pitch);
}
osd_lock_release(window->primlist->lock);
window->primlist->release_lock();
// unlock and flip
#if (!SDL_VERSION_ATLEAST(1,3,0))

2
src/osd/sdl/dview.c
View File

@ -423,6 +423,6 @@ GtkWidget *dview_new(const gchar *widget_name, const gchar *string1, const gchar
void dview_set_debug_view(DView *dv, running_machine *machine, debug_view_type type)
{
dv->view = machine->m_debug_view->alloc_view(type, dview_update, dv);
dv->view = machine->debug_view().alloc_view(type, dview_update, dv);
dv->dv_type = type;
}

2
src/osd/sdl/video.c
View File

@ -838,7 +838,7 @@ static void load_effect_overlay(running_machine *machine, const char *filename)
// set the overlay on all screens
for (screen_device *screen = screen_first(*machine); screen != NULL; screen = screen_next(screen))
render_container_set_overlay(render_container_get_screen(screen), effect_bitmap);
screen->container().set_overlay(effect_bitmap);
global_free(tempstr);
}

36
src/osd/sdl/window.c
View File

@ -347,14 +347,14 @@ void sdlwindow_blit_surface_size(sdl_window_info *window, int window_width, int
INT32 target_height = window_height;
// start with the minimum size
render_target_get_minimum_size(window->target, &newwidth, &newheight);
window->target->compute_minimum_size(newwidth, newheight);
// compute the appropriate visible area if we're trying to keepaspect
if (video_config.keepaspect)
{
// make sure the monitor is up-to-date
sdlvideo_monitor_refresh(window->monitor);
render_target_compute_visible_area(window->target, target_width, target_height, sdlvideo_monitor_get_aspect(window->monitor), render_target_get_orientation(window->target), &target_width, &target_height);
window->target->compute_visible_area(target_width, target_height, sdlvideo_monitor_get_aspect(window->monitor), window->target->orientation(), target_width, target_height);
desired_aspect = (float)target_width / (float)target_height;
}
@ -406,7 +406,7 @@ void sdlwindow_blit_surface_size(sdl_window_info *window, int window_width, int
}
//FIXME: really necessary to distinguish for yuv_modes ?
if ((render_target_get_layer_config(window->target) & LAYER_CONFIG_ZOOM_TO_SCREEN)
if (window->target->zoom_to_screen()
&& (window->scale_mode == VIDEO_SCALE_MODE_NONE ))
newwidth = window_width;
@ -695,12 +695,7 @@ int sdlwindow_video_window_create(running_machine *machine, int index, sdl_monit
window->rendered_event = osd_event_alloc(FALSE, TRUE);
// load the layout
window->target = render_target_alloc(machine, NULL, FALSE);
if (window->target == NULL)
{
osd_free(wp);
goto error;
}
window->target = machine->render().target_alloc();
// set the specific view
sprintf(option, SDLOPTION_VIEW("%d"), index);
@ -789,8 +784,7 @@ static void sdlwindow_video_window_destroy(running_machine *machine, sdl_window_
execute_async_wait(&sdlwindow_video_window_destroy_wt, &wp);
// free the render target, after the textures!
if (window->target != NULL)
render_target_free(window->target);
window->machine->render().target_free(window->target);
// free the event
osd_event_free(window->rendered_event);
@ -813,7 +807,7 @@ static void pick_best_mode(sdl_window_info *window, int *fswidth, int *fsheight)
float size_score, best_score = 0.0f;
// determine the minimum width/height for the selected target
render_target_get_minimum_size(window->target, &minimum_width, &minimum_height);
window->target->compute_minimum_size(minimum_width, minimum_height);
// use those as the target for now
target_width = minimum_width * MAX(1, window->prescale);
@ -880,7 +874,7 @@ static void pick_best_mode(sdl_window_info *window, int *fswidth, int *fsheight)
SDL_Rect **modes;
// determine the minimum width/height for the selected target
render_target_get_minimum_size(window->target, &minimum_width, &minimum_height);
window->target->compute_minimum_size(minimum_width, minimum_height);
// use those as the target for now
target_width = minimum_width * MAX(1, window->prescale);
@ -966,7 +960,7 @@ void sdlwindow_video_window_update(running_machine *machine, sdl_window_info *wi
int tempwidth, tempheight;
// see if the games video mode has changed
render_target_get_minimum_size(window->target, &tempwidth, &tempheight);
window->target->compute_minimum_size(tempwidth, tempheight);
if (tempwidth != window->minwidth || tempheight != window->minheight)
{
window->minwidth = tempwidth;
@ -1026,7 +1020,7 @@ static void set_starting_view(running_machine *machine, int index, sdl_window_in
viewindex = video_get_view_for_target(machine, window->target, view, index, video_config.numscreens);
// set the view
render_target_set_view(window->target, viewindex);
window->target->set_view(viewindex);
window->start_viewscreen=viewindex;
}
@ -1208,21 +1202,21 @@ static void constrain_to_aspect_ratio(sdl_window_info *window, int *window_width
{
case WMSZ_BOTTOM:
case WMSZ_TOP:
render_target_compute_visible_area(window->target, 10000, propheight, pixel_aspect, render_target_get_orientation(window->target), &propwidth, &propheight);
window->target->compute_visible_area(10000, propheight, pixel_aspect, window->target->orientation(), propwidth, propheight);
break;
case WMSZ_LEFT:
case WMSZ_RIGHT:
render_target_compute_visible_area(window->target, propwidth, 10000, pixel_aspect, render_target_get_orientation(window->target), &propwidth, &propheight);
window->target->compute_visible_area(propwidth, 10000, pixel_aspect, window->target->orientation(), propwidth, propheight);
break;
default:
render_target_compute_visible_area(window->target, propwidth, propheight, pixel_aspect, render_target_get_orientation(window->target), &propwidth, &propheight);
window->target->compute_visible_area(propwidth, propheight, pixel_aspect, window->target->orientation(), propwidth, propheight);
break;
}
// get the minimum width/height for the current layout
render_target_get_minimum_size(window->target, &minwidth, &minheight);
window->target->compute_minimum_size(minwidth, minheight);
// clamp against the absolute minimum
propwidth = MAX(propwidth, MIN_WINDOW_DIM);
@ -1255,7 +1249,7 @@ static void constrain_to_aspect_ratio(sdl_window_info *window, int *window_width
propheight = MIN(propheight, maxheight);
// compute the visible area based on the proposed rectangle
render_target_compute_visible_area(window->target, propwidth, propheight, pixel_aspect, render_target_get_orientation(window->target), &viswidth, &visheight);
window->target->compute_visible_area(propwidth, propheight, pixel_aspect, window->target->orientation(), viswidth, visheight);
*window_width = viswidth;
*window_height = visheight;
@ -1272,7 +1266,7 @@ static void get_min_bounds(sdl_window_info *window, int *window_width, int *wind
INT32 minwidth, minheight;
// get the minimum target size
render_target_get_minimum_size(window->target, &minwidth, &minheight);
window->target->compute_minimum_size(minwidth, minheight);
// expand to our minimum dimensions
if (minwidth < MIN_WINDOW_DIM)

4
src/osd/sdl/window.h
View File

@ -45,7 +45,7 @@ struct _sdl_window_info
int (*create)(sdl_window_info *window, int width, int height);
void (*resize)(sdl_window_info *window, int width, int height);
int (*draw)(sdl_window_info *window, UINT32 dc, int update);
const render_primitive_list *(*get_primitives)(sdl_window_info *window);
render_primitive_list &(*get_primitives)(sdl_window_info *window);
int (*xy_to_render_target)(sdl_window_info *window, int x, int y, int *xt, int *yt);
void (*destroy_all_textures)(sdl_window_info *window);
void (*destroy)(sdl_window_info *window);
@ -71,7 +71,7 @@ struct _sdl_window_info
// rendering info
osd_event * rendered_event;
render_target * target;
const render_primitive_list *primlist;
render_primitive_list *primlist;
// drawing data
void * dxdata;

16
src/osd/windows/debugwin.c
View File

@ -607,7 +607,7 @@ static void debugwin_window_free(debugwin_info *info)
for (viewnum = 0; viewnum < ARRAY_LENGTH(info->view); viewnum++)
if (info->view[viewnum].view != NULL)
{
info->machine->m_debug_view->free_view(*info->view[viewnum].view);
info->machine->debug_view().free_view(*info->view[viewnum].view);
info->view[viewnum].view = NULL;
}
@ -851,7 +851,7 @@ static int debugwin_view_create(debugwin_info *info, int which, debug_view_type
goto cleanup;
// create the debug view
view->view = info->machine->m_debug_view->alloc_view(type, debugwin_view_update, view);
view->view = info->machine->debug_view().alloc_view(type, debugwin_view_update, view);
if (view->view == NULL)
goto cleanup;
@ -859,7 +859,7 @@ static int debugwin_view_create(debugwin_info *info, int which, debug_view_type
cleanup:
if (view->view)
info->machine->m_debug_view->free_view(*view->view);
info->machine->debug_view().free_view(*view->view);
if (view->hscroll)
DestroyWindow(view->hscroll);
if (view->vscroll)
@ -1468,7 +1468,7 @@ static LRESULT CALLBACK debugwin_view_proc(HWND wnd, UINT message, WPARAM wparam
debug_view_xy topleft = info->view->visible_position();
topleft.x = debugwin_view_process_scroll(info, LOWORD(wparam), (HWND)lparam);
info->view->set_visible_position(topleft);
info->owner->machine->m_debug_view->flush_osd_updates();
info->owner->machine->debug_view().flush_osd_updates();
break;
}
@ -1478,7 +1478,7 @@ static LRESULT CALLBACK debugwin_view_proc(HWND wnd, UINT message, WPARAM wparam
debug_view_xy topleft = info->view->visible_position();
topleft.y = debugwin_view_process_scroll(info, LOWORD(wparam), (HWND)lparam);
info->view->set_visible_position(topleft);
info->owner->machine->m_debug_view->flush_osd_updates();
info->owner->machine->debug_view().flush_osd_updates();
break;
}
@ -2484,11 +2484,11 @@ void console_create_window(running_machine *machine)
cleanup:
if (info->view[2].view)
machine->m_debug_view->free_view(*info->view[2].view);
machine->debug_view().free_view(*info->view[2].view);
if (info->view[1].view)
machine->m_debug_view->free_view(*info->view[1].view);
machine->debug_view().free_view(*info->view[1].view);
if (info->view[0].view)
machine->m_debug_view->free_view(*info->view[0].view);
machine->debug_view().free_view(*info->view[0].view);
}

31
src/osd/windows/drawd3d.c
View File

@ -439,7 +439,7 @@ INLINE void reset_render_states(d3d_info *d3d)
static void drawd3d_exit(void);
static int drawd3d_window_init(win_window_info *window);
static void drawd3d_window_destroy(win_window_info *window);
static const render_primitive_list *drawd3d_window_get_primitives(win_window_info *window);
static render_primitive_list *drawd3d_window_get_primitives(win_window_info *window);
static int drawd3d_window_draw(win_window_info *window, HDC dc, int update);
// devices
@ -591,7 +591,7 @@ static void drawd3d_window_destroy(win_window_info *window)
// drawd3d_window_get_primitives
//============================================================
static const render_primitive_list *drawd3d_window_get_primitives(win_window_info *window)
static render_primitive_list *drawd3d_window_get_primitives(win_window_info *window)
{
d3d_info *d3d = (d3d_info *)window->drawdata;
RECT client;
@ -599,10 +599,10 @@ static const render_primitive_list *drawd3d_window_get_primitives(win_window_inf
GetClientRectExceptMenu(window->hwnd, &client, window->fullscreen);
if (rect_width(&client) > 0 && rect_height(&client) > 0)
{
render_target_set_bounds(window->target, rect_width(&client), rect_height(&client), winvideo_monitor_get_aspect(window->monitor));
render_target_set_max_update_rate(window->target, (d3d->refresh == 0) ? d3d->origmode.RefreshRate : d3d->refresh);
window->target->set_bounds(rect_width(&client), rect_height(&client), winvideo_monitor_get_aspect(window->monitor));
window->target->set_max_update_rate((d3d->refresh == 0) ? d3d->origmode.RefreshRate : d3d->refresh);
}
return render_target_get_primitives(window->target);
return &window->target->get_primitives();
}
@ -614,7 +614,7 @@ static const render_primitive_list *drawd3d_window_get_primitives(win_window_inf
static int drawd3d_window_draw(win_window_info *window, HDC dc, int update)
{
d3d_info *d3d = (d3d_info *)window->drawdata;
const render_primitive *prim;
render_primitive *prim;
HRESULT result;
// if we haven't been created, just punt
@ -644,8 +644,8 @@ static int drawd3d_window_draw(win_window_info *window, HDC dc, int update)
mtlog_add("drawd3d_window_draw: begin");
// first update any textures
osd_lock_acquire(window->primlist->lock);
for (prim = window->primlist->head; prim != NULL; prim = prim->next)
window->primlist->acquire_lock();
for (prim = window->primlist->first(); prim != NULL; prim = prim->next())
if (prim->texture.base != NULL)
texture_update(d3d, prim);
@ -658,19 +658,22 @@ mtlog_add("drawd3d_window_draw: begin_scene");
// loop over primitives
mtlog_add("drawd3d_window_draw: primitive loop begin");
for (prim = window->primlist->head; prim != NULL; prim = prim->next)
for (prim = window->primlist->first(); prim != NULL; prim = prim->next())
switch (prim->type)
{
case RENDER_PRIMITIVE_LINE:
case render_primitive::LINE:
draw_line(d3d, prim);
break;
case RENDER_PRIMITIVE_QUAD:
case render_primitive::QUAD:
draw_quad(d3d, prim);
break;
default:
throw emu_fatalerror("Unexpected render_primitive type");
}
mtlog_add("drawd3d_window_draw: primitive loop end");
osd_lock_release(window->primlist->lock);
window->primlist->release_lock();
// flush any pending polygons
mtlog_add("drawd3d_window_draw: flush_pending begin");
@ -796,7 +799,7 @@ try_again:
mame_printf_verbose("Direct3D: Device created at %dx%d\n", d3d->width, d3d->height);
// set the max texture size
render_target_set_max_texture_size(window->target, d3d->texture_max_width, d3d->texture_max_height);
window->target->set_max_texture_size(d3d->texture_max_width, d3d->texture_max_height);
mame_printf_verbose("Direct3D: Max texture size = %dx%d\n", (int)d3d->texture_max_width, (int)d3d->texture_max_height);
// set the gamma if we need to
@ -1288,7 +1291,7 @@ static void pick_best_mode(win_window_info *window)
// note: technically we should not be calling this from an alternate window
// thread; however, it is only done during init time, and the init code on
// the main thread is waiting for us to finish, so it is safe to do so here
render_target_get_minimum_size(window->target, &minwidth, &minheight);
window->target->compute_minimum_size(minwidth, minheight);
// use those as the target for now
target_width = minwidth;

58
src/osd/windows/drawdd.c
View File

@ -178,7 +178,7 @@ INLINE int better_mode(int width0, int height0, int width1, int height1, float d
static void drawdd_exit(void);
static int drawdd_window_init(win_window_info *window);
static void drawdd_window_destroy(win_window_info *window);
static const render_primitive_list *drawdd_window_get_primitives(win_window_info *window);
static render_primitive_list *drawdd_window_get_primitives(win_window_info *window);
static int drawdd_window_draw(win_window_info *window, HDC dc, int update);
// surface management
@ -201,14 +201,14 @@ static void get_adapter_for_monitor(dd_info *dd, win_monitor_info *monitor);
static void pick_best_mode(win_window_info *window);
// rendering
static void drawdd_rgb888_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_bgr888_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb565_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb555_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb888_nr_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_bgr888_nr_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb565_nr_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb555_nr_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb888_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_bgr888_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb565_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb555_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb888_nr_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_bgr888_nr_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb565_nr_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawdd_rgb555_nr_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
@ -327,15 +327,15 @@ static void drawdd_window_destroy(win_window_info *window)
// drawdd_window_get_primitives
//============================================================
static const render_primitive_list *drawdd_window_get_primitives(win_window_info *window)
static render_primitive_list *drawdd_window_get_primitives(win_window_info *window)
{
dd_info *dd = (dd_info *)window->drawdata;
compute_blit_surface_size(window);
render_target_set_bounds(window->target, dd->blitwidth, dd->blitheight, 0);
render_target_set_max_update_rate(window->target, (dd->refresh == 0) ? dd->origmode.dwRefreshRate : dd->refresh);
window->target->set_bounds(dd->blitwidth, dd->blitheight, 0);
window->target->set_max_update_rate((dd->refresh == 0) ? dd->origmode.dwRefreshRate : dd->refresh);
return render_target_get_primitives(window->target);
return &window->target->get_primitives();
}
@ -347,7 +347,7 @@ static const render_primitive_list *drawdd_window_get_primitives(win_window_info
static int drawdd_window_draw(win_window_info *window, HDC dc, int update)
{
dd_info *dd = (dd_info *)window->drawdata;
const render_primitive *prim;
render_primitive *prim;
int usemembuffer = FALSE;
HRESULT result;
@ -386,10 +386,10 @@ static int drawdd_window_draw(win_window_info *window, HDC dc, int update)
}
// render to it
osd_lock_acquire(window->primlist->lock);
window->primlist->acquire_lock();
// scan the list of primitives for tricky stuff
for (prim = window->primlist->head; prim != NULL; prim = prim->next)
for (prim = window->primlist->first(); prim != NULL; prim = prim->next())
if (PRIMFLAG_GET_BLENDMODE(prim->flags) != BLENDMODE_NONE ||
(prim->texture.base != NULL && PRIMFLAG_GET_TEXFORMAT(prim->flags) == TEXFORMAT_ARGB32))
{
@ -405,10 +405,10 @@ static int drawdd_window_draw(win_window_info *window, HDC dc, int update)
// based on the target format, use one of our standard renderers
switch (dd->blitdesc.ddpfPixelFormat.dwRBitMask)
{
case 0x00ff0000: drawdd_rgb888_draw_primitives(window->primlist->head, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0x000000ff: drawdd_bgr888_draw_primitives(window->primlist->head, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0xf800: drawdd_rgb565_draw_primitives(window->primlist->head, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0x7c00: drawdd_rgb555_draw_primitives(window->primlist->head, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0x00ff0000: drawdd_rgb888_draw_primitives(*window->primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0x000000ff: drawdd_bgr888_draw_primitives(*window->primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0xf800: drawdd_rgb565_draw_primitives(*window->primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0x7c00: drawdd_rgb555_draw_primitives(*window->primlist, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
default:
mame_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)dd->blitdesc.ddpfPixelFormat.dwRBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwGBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwBBitMask);
break;
@ -441,16 +441,16 @@ static int drawdd_window_draw(win_window_info *window, HDC dc, int update)
// based on the target format, use one of our standard renderers
switch (dd->blitdesc.ddpfPixelFormat.dwRBitMask)
{
case 0x00ff0000: drawdd_rgb888_nr_draw_primitives(window->primlist->head, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
case 0x000000ff: drawdd_bgr888_nr_draw_primitives(window->primlist->head, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
case 0xf800: drawdd_rgb565_nr_draw_primitives(window->primlist->head, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
case 0x7c00: drawdd_rgb555_nr_draw_primitives(window->primlist->head, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
case 0x00ff0000: drawdd_rgb888_nr_draw_primitives(*window->primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
case 0x000000ff: drawdd_bgr888_nr_draw_primitives(*window->primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
case 0xf800: drawdd_rgb565_nr_draw_primitives(*window->primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
case 0x7c00: drawdd_rgb555_nr_draw_primitives(*window->primlist, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
default:
mame_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)dd->blitdesc.ddpfPixelFormat.dwRBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwGBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwBBitMask);
break;
}
}
osd_lock_release(window->primlist->lock);
window->primlist->release_lock();
// unlock and blit
result = IDirectDrawSurface7_Unlock(dd->blit, NULL);
@ -879,7 +879,7 @@ static void compute_blit_surface_size(win_window_info *window)
RECT client;
// start with the minimum size
render_target_get_minimum_size(window->target, &newwidth, &newheight);
window->target->compute_minimum_size(newwidth, newheight);
// get the window's client rectangle
GetClientRect(window->hwnd, &client);
@ -909,7 +909,7 @@ static void compute_blit_surface_size(win_window_info *window)
if (video_config.keepaspect)
{
win_monitor_info *monitor = winwindow_video_window_monitor(window, NULL);
render_target_compute_visible_area(window->target, target_width, target_height, winvideo_monitor_get_aspect(monitor), render_target_get_orientation(window->target), &target_width, &target_height);
window->target->compute_visible_area(target_width, target_height, winvideo_monitor_get_aspect(monitor), window->target->orientation(), target_width, target_height);
desired_aspect = (float)target_width / (float)target_height;
}
@ -1054,7 +1054,7 @@ static void blit_to_primary(win_window_info *window, int srcwidth, int srcheight
else if (video_config.keepaspect)
{
// compute the appropriate visible area
render_target_compute_visible_area(window->target, rect_width(&outer), rect_height(&outer), winvideo_monitor_get_aspect(monitor), render_target_get_orientation(window->target), &dstwidth, &dstheight);
window->target->compute_visible_area(rect_width(&outer), rect_height(&outer), winvideo_monitor_get_aspect(monitor), window->target->orientation(), dstwidth, dstheight);
}
// center within
@ -1325,7 +1325,7 @@ static void pick_best_mode(win_window_info *window)
// note: technically we should not be calling this from an alternate window
// thread; however, it is only done during init time, and the init code on
// the main thread is waiting for us to finish, so it is safe to do so here
render_target_get_minimum_size(window->target, &einfo.minimum_width, &einfo.minimum_height);
window->target->compute_minimum_size(einfo.minimum_width, einfo.minimum_height);
// use those as the target for now
einfo.target_width = einfo.minimum_width * MAX(1, video_config.prescale);

16
src/osd/windows/drawgdi.c
View File

@ -75,11 +75,11 @@ struct _gdi_info
static void drawgdi_exit(void);
static int drawgdi_window_init(win_window_info *window);
static void drawgdi_window_destroy(win_window_info *window);
static const render_primitive_list *drawgdi_window_get_primitives(win_window_info *window);
static render_primitive_list *drawgdi_window_get_primitives(win_window_info *window);
static int drawgdi_window_draw(win_window_info *window, HDC dc, int update);
// rendering
static void drawgdi_rgb888_draw_primitives(const render_primitive *primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
static void drawgdi_rgb888_draw_primitives(const render_primitive_list &primlist, void *dstdata, UINT32 width, UINT32 height, UINT32 pitch);
@ -172,12 +172,12 @@ static void drawgdi_window_destroy(win_window_info *window)
// drawgdi_window_get_primitives
//============================================================
static const render_primitive_list *drawgdi_window_get_primitives(win_window_info *window)
static render_primitive_list *drawgdi_window_get_primitives(win_window_info *window)
{
RECT client;
GetClientRect(window->hwnd, &client);
render_target_set_bounds(window->target, rect_width(&client), rect_height(&client), winvideo_monitor_get_aspect(window->monitor));
return render_target_get_primitives(window->target);
window->target->set_bounds(rect_width(&client), rect_height(&client), winvideo_monitor_get_aspect(window->monitor));
return &window->target->get_primitives();
}
@ -213,9 +213,9 @@ static int drawgdi_window_draw(win_window_info *window, HDC dc, int update)
}
// draw the primitives to the bitmap
osd_lock_acquire(window->primlist->lock);
drawgdi_rgb888_draw_primitives(window->primlist->head, gdi->bmdata, width, height, pitch);
osd_lock_release(window->primlist->lock);
window->primlist->acquire_lock();
drawgdi_rgb888_draw_primitives(*window->primlist, gdi->bmdata, width, height, pitch);
window->primlist->release_lock();
// fill in bitmap-specific info
gdi->bminfo.bmiHeader.biWidth = pitch;

8
src/osd/windows/drawnone.c
View File

@ -59,7 +59,7 @@
static void drawnone_exit(void);
static int drawnone_window_init(win_window_info *window);
static void drawnone_window_destroy(win_window_info *window);
static const render_primitive_list *drawnone_window_get_primitives(win_window_info *window);
static render_primitive_list *drawnone_window_get_primitives(win_window_info *window);
static int drawnone_window_draw(win_window_info *window, HDC dc, int update);
@ -116,12 +116,12 @@ static void drawnone_window_destroy(win_window_info *window)
// drawnone_window_get_primitives
//============================================================
static const render_primitive_list *drawnone_window_get_primitives(win_window_info *window)
static render_primitive_list *drawnone_window_get_primitives(win_window_info *window)
{
RECT client;
GetClientRect(window->hwnd, &client);
render_target_set_bounds(window->target, rect_width(&client), rect_height(&client), winvideo_monitor_get_aspect(window->monitor));
return render_target_get_primitives(window->target);
window->target->set_bounds(rect_width(&client), rect_height(&client), winvideo_monitor_get_aspect(window->monitor));
return &window->target->get_primitives();
}

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

@ -490,7 +490,7 @@ static void load_effect_overlay(running_machine *machine, const char *filename)
// set the overlay on all screens
for (screen_device *screen = screen_first(*machine); screen != NULL; screen = screen_next(screen))
render_container_set_overlay(render_container_get_screen(screen), effect_bitmap);
screen->container().set_overlay(effect_bitmap);
global_free(tempstr);
}

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

@ -636,18 +636,16 @@ void winwindow_video_window_create(running_machine *machine, int index, win_moni
window->render_lock = osd_lock_alloc();
// load the layout
window->target = render_target_alloc(machine, NULL, 0);
if (window->target == NULL)
fatalerror("Error creating render target for window %d", index);
window->target = machine->render().target_alloc();
// set the specific view
sprintf(option, "view%d", index);
set_starting_view(index, window, options_get_string(machine->options(), option));
// remember the current values in case they change
window->targetview = render_target_get_view(window->target);
window->targetorient = render_target_get_orientation(window->target);
window->targetlayerconfig = render_target_get_layer_config(window->target);
window->targetview = window->target->view();
window->targetorient = window->target->orientation();
window->targetlayerconfig = window->target->layer_config();
// make the window title
if (video_config.numscreens == 1)
@ -702,8 +700,7 @@ static void winwindow_video_window_destroy(win_window_info *window)
SendMessage(window->hwnd, WM_USER_SELF_TERMINATE, 0, 0);
// free the render target
if (window->target != NULL)
render_target_free(window->target);
window->machine->render().target_free(window->target);
// free the lock
osd_lock_free(window->render_lock);
@ -728,9 +725,9 @@ void winwindow_video_window_update(win_window_info *window)
mtlog_add("winwindow_video_window_update: begin");
// see if the target has changed significantly in window mode
targetview = render_target_get_view(window->target);
targetorient = render_target_get_orientation(window->target);
targetlayerconfig = render_target_get_layer_config(window->target);
targetview = window->target->view();
targetorient = window->target->orientation();
targetlayerconfig = window->target->layer_config();
if (targetview != window->targetview || targetorient != window->targetorient || targetlayerconfig != window->targetlayerconfig)
{
window->targetview = targetview;
@ -763,7 +760,7 @@ void winwindow_video_window_update(win_window_info *window)
// only render if we were able to get the lock
if (got_lock)
{
const render_primitive_list *primlist;
render_primitive_list *primlist;
mtlog_add("winwindow_video_window_update: got lock");
@ -873,7 +870,7 @@ static void set_starting_view(int index, win_window_info *window, const char *vi
viewindex = video_get_view_for_target(window->machine, window->target, view, index, video_config.numscreens);
// set the view
render_target_set_view(window->target, viewindex);
window->target->set_view(viewindex);
}
@ -1361,7 +1358,7 @@ LRESULT CALLBACK winwindow_video_window_proc(HWND wnd, UINT message, WPARAM wpar
HDC hdc = GetDC(wnd);
mtlog_add("winwindow_video_window_proc: WM_USER_REDRAW begin");
window->primlist = (const render_primitive_list *)lparam;
window->primlist = (render_primitive_list *)lparam;
draw_video_contents(window, hdc, FALSE);
mtlog_add("winwindow_video_window_proc: WM_USER_REDRAW end");
@ -1480,21 +1477,21 @@ static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int a
{
case WMSZ_BOTTOM:
case WMSZ_TOP:
render_target_compute_visible_area(window->target, 10000, propheight, pixel_aspect, render_target_get_orientation(window->target), &propwidth, &propheight);
window->target->compute_visible_area(10000, propheight, pixel_aspect, window->target->orientation(), propwidth, propheight);
break;
case WMSZ_LEFT:
case WMSZ_RIGHT:
render_target_compute_visible_area(window->target, propwidth, 10000, pixel_aspect, render_target_get_orientation(window->target), &propwidth, &propheight);
window->target->compute_visible_area(propwidth, 10000, pixel_aspect, window->target->orientation(), propwidth, propheight);
break;
default:
render_target_compute_visible_area(window->target, propwidth, propheight, pixel_aspect, render_target_get_orientation(window->target), &propwidth, &propheight);
window->target->compute_visible_area(propwidth, propheight, pixel_aspect, window->target->orientation(), propwidth, propheight);
break;
}
// get the minimum width/height for the current layout
render_target_get_minimum_size(window->target, &minwidth, &minheight);
window->target->compute_minimum_size(minwidth, minheight);
// clamp against the absolute minimum
propwidth = MAX(propwidth, MIN_WINDOW_DIM);
@ -1527,7 +1524,7 @@ static void constrain_to_aspect_ratio(win_window_info *window, RECT *rect, int a
propheight = MIN(propheight, maxheight);
// compute the visible area based on the proposed rectangle
render_target_compute_visible_area(window->target, propwidth, propheight, pixel_aspect, render_target_get_orientation(window->target), &viswidth, &visheight);
window->target->compute_visible_area(propwidth, propheight, pixel_aspect, window->target->orientation(), viswidth, visheight);
// compute the adjustments we need to make
adjwidth = (viswidth + extrawidth) - rect_width(rect);
@ -1576,7 +1573,7 @@ static void get_min_bounds(win_window_info *window, RECT *bounds, int constrain)
assert(GetCurrentThreadId() == window_threadid);
// get the minimum target size
render_target_get_minimum_size(window->target, &minwidth, &minheight);
window->target->compute_minimum_size(minwidth, minheight);
// expand to our minimum dimensions
if (minwidth < MIN_WINDOW_DIM)

4
src/osd/windows/window.h
View File

@ -101,7 +101,7 @@ struct _win_window_info
int targetview;
int targetorient;
int targetlayerconfig;
const render_primitive_list *primlist;
render_primitive_list *primlist;
// input info
DWORD lastclicktime;
@ -121,7 +121,7 @@ struct _win_draw_callbacks
void (*exit)(void);
int (*window_init)(win_window_info *window);
const render_primitive_list *(*window_get_primitives)(win_window_info *window);
render_primitive_list *(*window_get_primitives)(win_window_info *window);
int (*window_draw)(win_window_info *window, HDC dc, int update);
void (*window_destroy)(win_window_info *window);
};