Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-05 08:41:31 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Make sliders use an std::vector instead of a linked list, nw

Browse Source
This commit is contained in:
therealmogminer@gmail.com 2016-04-10 02:25:11 +02:00
parent 74a8e5d1dd
commit 8719535cbc
25 changed files with 184 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/emu/ui/menu.cpp
View File

@ -296,7 +296,17 @@ void ui_menu::set_special_main_menu(bool special)
// end of the menu
//-------------------------------------------------
void ui_menu::item_append(const char *text, const char *subtext, UINT32 flags, void *ref)
void ui_menu::item_append(ui_menu_item item)
{
item_append(item.text, item.subtext, item.flags, item.ref, item.type);
}
//-------------------------------------------------
// item_append - append a new item to the
// end of the menu
//-------------------------------------------------
void ui_menu::item_append(const char *text, const char *subtext, UINT32 flags, void *ref, ui_menu_item_type type)
{
// only allow multiline as the first item
if ((flags & MENU_FLAG_MULTILINE) != 0)
@ -312,6 +322,7 @@ void ui_menu::item_append(const char *text, const char *subtext, UINT32 flags, v
pitem.subtext = (subtext != nullptr) ? pool_strdup(subtext) : nullptr;
pitem.flags = flags;
pitem.ref = ref;
pitem.type = type;
// append to array
int index = item.size();
@ -380,6 +391,7 @@ const ui_menu_event *ui_menu::process(UINT32 flags)
if (menu_event.iptkey != IPT_INVALID && selected >= 0 && selected < item.size())
{
menu_event.itemref = item[selected].ref;
menu_event.type = item[selected].type;
return &menu_event;
}
return nullptr;

25
src/emu/ui/menu.h
View File

@ -53,6 +53,12 @@ enum ui_menu_reset_options
UI_MENU_RESET_REMEMBER_REF
};
// types of menu items (TODO: please expand)
enum class ui_menu_item_type
{
UI_MENU_ITEM_TYPE_UNKNOWN,
UI_MENU_ITEM_TYPE_SLIDER
};
/***************************************************************************
@ -62,9 +68,10 @@ enum ui_menu_reset_options
// menu-related events
struct ui_menu_event
{
void *itemref; // reference for the selected item
int iptkey; // one of the IPT_* values from inptport.h
unicode_char unichar; // unicode character if iptkey == IPT_SPECIAL
void *itemref; // reference for the selected item
ui_menu_item_type type; // item type (eventually will go away when itemref is proper ui_menu_item class rather than void*)
int iptkey; // one of the IPT_* values from inptport.h
unicode_char unichar; // unicode character if iptkey == IPT_SPECIAL
};
struct ui_menu_pool
@ -78,10 +85,11 @@ struct ui_menu_pool
class ui_menu_item
{
public:
const char *text;
const char *subtext;
UINT32 flags;
void *ref;
const char *text;
const char *subtext;
UINT32 flags;
void *ref;
ui_menu_item_type type; // item type (eventually will go away when itemref is proper ui_menu_item class rather than void*)
inline bool is_selectable() const;
};
@ -111,7 +119,8 @@ public:
void reset(ui_menu_reset_options options);
// append a new item to the end of the menu
void item_append(const char *text, const char *subtext, UINT32 flags, void *ref);
void item_append(const char *text, const char *subtext, UINT32 flags, void *ref, ui_menu_item_type type = ui_menu_item_type::UI_MENU_ITEM_TYPE_UNKNOWN);
void item_append(ui_menu_item item);
// process a menu, drawing it and returning any interesting events
const ui_menu_event *process(UINT32 flags);

29
src/emu/ui/sliders.cpp
View File

@ -39,7 +39,7 @@ void ui_menu_sliders::handle()
if (menu_event != nullptr)
{
/* handle keys if there is a valid item selected */
if (menu_event->itemref != nullptr)
if (menu_event->itemref != nullptr && menu_event->type == ui_menu_item_type::UI_MENU_ITEM_TYPE_SLIDER)
{
const slider_state *slider = (const slider_state *)menu_event->itemref;
INT32 curvalue = (*slider->update)(machine(), slider->arg, slider->id, nullptr, SLIDER_NOCHANGE);
@ -140,27 +140,32 @@ void ui_menu_sliders::populate()
std::string tempstring;
/* add UI sliders */
for (const slider_state *curslider = machine().ui().get_slider_list(); curslider != nullptr; curslider = curslider->next)
std::vector<slider_state *> ui_sliders = machine().ui().get_slider_list();
for (slider_state* slider : ui_sliders)
{
INT32 curval = (*curslider->update)(machine(), curslider->arg, curslider->id, &tempstring, SLIDER_NOCHANGE);
INT32 curval = (*slider->update)(machine(), slider->arg, slider->id, &tempstring, SLIDER_NOCHANGE);
UINT32 flags = 0;
if (curval > curslider->minval)
if (curval > slider->minval)
flags |= MENU_FLAG_LEFT_ARROW;
if (curval < curslider->maxval)
if (curval < slider->maxval)
flags |= MENU_FLAG_RIGHT_ARROW;
item_append(curslider->description, tempstring.c_str(), flags, (void *)curslider);
item_append(slider->description, tempstring.c_str(), flags, (void *)slider, ui_menu_item_type::UI_MENU_ITEM_TYPE_SLIDER);
}
/* add OSD sliders */
for (const slider_state *curslider = (slider_state*)machine().osd().get_slider_list(); curslider != nullptr; curslider = curslider->next)
item_append(MENU_SEPARATOR_ITEM, nullptr, 0, nullptr);
/* add OSD options */
std::vector<slider_state *> osd_sliders = machine().osd().get_slider_list();
for (slider_state* slider : osd_sliders)
{
INT32 curval = (*curslider->update)(machine(), curslider->arg, curslider->id, &tempstring, SLIDER_NOCHANGE);
INT32 curval = (*slider->update)(machine(), slider->arg, slider->id, &tempstring, SLIDER_NOCHANGE);
UINT32 flags = 0;
if (curval > curslider->minval)
if (curval > slider->minval)
flags |= MENU_FLAG_LEFT_ARROW;
if (curval < curslider->maxval)
if (curval < slider->maxval)
flags |= MENU_FLAG_RIGHT_ARROW;
item_append(curslider->description, tempstring.c_str(), flags, (void *)curslider);
item_append(slider->description, tempstring.c_str(), flags, (void *)slider, ui_menu_item_type::UI_MENU_ITEM_TYPE_SLIDER);
}
custombottom = 2.0f * machine().ui().get_line_height() + 2.0f * UI_BOX_TB_BORDER;

4
src/emu/ui/sliders.h
View File

@ -27,6 +27,10 @@ public:
static UINT32 ui_handler(running_machine &machine, render_container *container, UINT32 state);
private:
enum {
INPUT_GROUPS,
INPUT_SPECIFIC,
};
bool m_menuless_mode;
bool m_hidden;
};

124
src/emu/ui/ui.cpp
View File

@ -118,7 +118,7 @@ std::string ui_manager::messagebox_poptext;
rgb_t ui_manager::messagebox_backcolor;
// slider info
slider_state *ui_manager::slider_list;
std::vector<slider_state *> ui_manager::slider_list;
slider_state *ui_manager::slider_current;
@ -128,7 +128,6 @@ slider_state *ui_manager::slider_current;
// slider controls
static slider_state *slider_alloc(running_machine &machine, const char *title, INT32 minval, INT32 defval, INT32 maxval, INT32 incval, slider_update update, void *arg);
static slider_state *slider_init(running_machine &machine);
static INT32 slider_volume(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
static INT32 slider_mixervol(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
static INT32 slider_adjuster(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
@ -338,7 +337,15 @@ void ui_manager::exit()
void ui_manager::initialize(running_machine &machine)
{
// initialize the on-screen display system
slider_list = slider_current = slider_init(machine);
slider_list = slider_init(machine);
if (slider_list.size() > 0)
{
slider_current = slider_list[0];
}
else
{
slider_current = nullptr;
}
}
@ -1866,7 +1873,7 @@ UINT32 ui_manager::handler_confirm_quit(running_machine &machine, render_contain
// ui_get_slider_list - get the list of sliders
//-------------------------------------------------
const slider_state *ui_manager::get_slider_list(void)
std::vector<slider_state *>& ui_manager::get_slider_list(void)
{
return slider_list;
}
@ -1894,43 +1901,40 @@ static slider_state *slider_alloc(running_machine &machine, const char *title, I
}
//-------------------------------------------------
// slider_init - initialize the list of slider
//----------------------------------------------------------
// ui_manager::slider_init - initialize the list of slider
// controls
//-------------------------------------------------
//----------------------------------------------------------
static slider_state *slider_init(running_machine &machine)
std::vector<slider_state *> ui_manager::slider_init(running_machine &machine)
{
slider_state *listhead = nullptr;
slider_state **tailptr = &listhead;
std::string str;
int item;
std::vector<slider_state *> sliders;
// add overall volume
*tailptr = slider_alloc(machine, _("Master Volume"), -32, 0, 0, 1, slider_volume, nullptr);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, _("Master Volume"), -32, 0, 0, 1, slider_volume, nullptr));
// add per-channel volume
mixer_input info;
for (item = 0; machine.sound().indexed_mixer_input(item, info); item++)
for (int item = 0; machine.sound().indexed_mixer_input(item, info); item++)
{
INT32 maxval = 2000;
INT32 defval = 1000;
str = string_format(_("%1$s Volume"), info.stream->input_name(info.inputnum));
*tailptr = slider_alloc(machine, str.c_str(), 0, defval, maxval, 20, slider_mixervol, (void *)(FPTR)item);
tailptr = &(*tailptr)->next;
std::string str = string_format(_("%1$s Volume"), info.stream->input_name(info.inputnum));
sliders.push_back(slider_alloc(machine, str.c_str(), 0, defval, maxval, 20, slider_mixervol, (void *)(FPTR)item));
}
// add analog adjusters
for (ioport_port &port : machine.ioport().ports())
{
for (ioport_field &field : port.fields())
{
if (field.type() == IPT_ADJUSTER)
{
void *param = (void *)&field;
*tailptr = slider_alloc(machine, field.name(), field.minval(), field.defvalue(), field.maxval(), 1, slider_adjuster, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, field.name(), field.minval(), field.defvalue(), field.maxval(), 1, slider_adjuster, (void *)&field));
}
}
}
// add CPU overclocking (cheat only)
if (machine.options().cheat())
@ -1939,9 +1943,8 @@ static slider_state *slider_init(running_machine &machine)
for (device_execute_interface *exec = iter.first(); exec != nullptr; exec = iter.next())
{
void *param = (void *)&exec->device();
str = string_format(_("Overclock CPU %1$s"), exec->device().tag());
*tailptr = slider_alloc(machine, str.c_str(), 10, 1000, 2000, 1, slider_overclock, param);
tailptr = &(*tailptr)->next;
std::string str = string_format(_("Overclock CPU %1$s"), exec->device().tag());
sliders.push_back(slider_alloc(machine, str.c_str(), 10, 1000, 2000, 1, slider_overclock, param));
}
}
@ -1959,39 +1962,32 @@ static slider_state *slider_init(running_machine &machine)
// add refresh rate tweaker
if (machine.options().cheat())
{
str = string_format(_("%1$s Refresh Rate"), screen_desc);
*tailptr = slider_alloc(machine, str.c_str(), -10000, 0, 10000, 1000, slider_refresh, param);
tailptr = &(*tailptr)->next;
std::string str = string_format(_("%1$s Refresh Rate"), screen_desc);
sliders.push_back(slider_alloc(machine, str.c_str(), -10000, 0, 10000, 1000, slider_refresh, param));
}
// add standard brightness/contrast/gamma controls per-screen
str = string_format(_("%1$s Brightness"), screen_desc);
*tailptr = slider_alloc(machine, str.c_str(), 100, 1000, 2000, 10, slider_brightness, param);
tailptr = &(*tailptr)->next;
std::string str = string_format(_("%1$s Brightness"), screen_desc);
sliders.push_back(slider_alloc(machine, str.c_str(), 100, 1000, 2000, 10, slider_brightness, param));
str = string_format(_("%1$s Contrast"), screen_desc);
*tailptr = slider_alloc(machine, str.c_str(), 100, 1000, 2000, 50, slider_contrast, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), 100, 1000, 2000, 50, slider_contrast, param));
str = string_format(_("%1$s Gamma"), screen_desc);
*tailptr = slider_alloc(machine, str.c_str(), 100, 1000, 3000, 50, slider_gamma, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), 100, 1000, 3000, 50, slider_gamma, param));
// add scale and offset controls per-screen
str = string_format(_("%1$s Horiz Stretch"), screen_desc);
*tailptr = slider_alloc(machine, str.c_str(), 500, defxscale, 1500, 2, slider_xscale, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), 500, defxscale, 1500, 2, slider_xscale, param));
str = string_format(_("%1$s Horiz Position"), screen_desc);
*tailptr = slider_alloc(machine, str.c_str(), -500, defxoffset, 500, 2, slider_xoffset, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), -500, defxoffset, 500, 2, slider_xoffset, param));
str = string_format(_("%1$s Vert Stretch"), screen_desc);
*tailptr = slider_alloc(machine, str.c_str(), 500, defyscale, 1500, 2, slider_yscale, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), 500, defyscale, 1500, 2, slider_yscale, param));
str = string_format(_("%1$s Vert Position"), screen_desc);
*tailptr = slider_alloc(machine, str.c_str(), -500, defyoffset, 500, 2, slider_yoffset, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), -500, defyoffset, 500, 2, slider_yoffset, param));
}
laserdisc_device_iterator lditer(machine.root_device());
for (laserdisc_device *laserdisc = lditer.first(); laserdisc != nullptr; laserdisc = lditer.next())
{
if (laserdisc->overlay_configured())
{
laserdisc_overlay_config config;
@ -2003,52 +1999,48 @@ static slider_state *slider_init(running_machine &machine)
void *param = (void *)laserdisc;
// add scale and offset controls per-overlay
str = string_format(_("Laserdisc '%1$s' Horiz Stretch"), laserdisc->tag());
*tailptr = slider_alloc(machine, str.c_str(), 500, (defxscale == 0) ? 1000 : defxscale, 1500, 2, slider_overxscale, param);
tailptr = &(*tailptr)->next;
std::string str = string_format(_("Laserdisc '%1$s' Horiz Stretch"), laserdisc->tag());
sliders.push_back(slider_alloc(machine, str.c_str(), 500, (defxscale == 0) ? 1000 : defxscale, 1500, 2, slider_overxscale, param));
str = string_format(_("Laserdisc '%1$s' Horiz Position"), laserdisc->tag());
*tailptr = slider_alloc(machine, str.c_str(), -500, defxoffset, 500, 2, slider_overxoffset, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), -500, defxoffset, 500, 2, slider_overxoffset, param));
str = string_format(_("Laserdisc '%1$s' Vert Stretch"), laserdisc->tag());
*tailptr = slider_alloc(machine, str.c_str(), 500, (defyscale == 0) ? 1000 : defyscale, 1500, 2, slider_overyscale, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), 500, (defyscale == 0) ? 1000 : defyscale, 1500, 2, slider_overyscale, param));
str = string_format(_("Laserdisc '%1$s' Vert Position"), laserdisc->tag());
*tailptr = slider_alloc(machine, str.c_str(), -500, defyoffset, 500, 2, slider_overyoffset, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), -500, defyoffset, 500, 2, slider_overyoffset, param));
}
}
for (screen_device *screen = scriter.first(); screen != nullptr; screen = scriter.next())
{
if (screen->screen_type() == SCREEN_TYPE_VECTOR)
{
// add vector control
*tailptr = slider_alloc(machine, _("Vector Flicker"), 0, 0, 1000, 10, slider_flicker, nullptr);
tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(machine, _("Beam Width Minimum"), 1, 100, 1000, 1, slider_beam_width_min, nullptr);
tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(machine, _("Beam Width Maximum"), 1, 100, 1000, 1, slider_beam_width_max, nullptr);
tailptr = &(*tailptr)->next;
*tailptr = slider_alloc(machine, _("Beam Intensity Weight"), -1000, 0, 1000, 10, slider_beam_intensity_weight, nullptr);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, _("Vector Flicker"), 0, 0, 1000, 10, slider_flicker, nullptr));
sliders.push_back(slider_alloc(machine, _("Beam Width Minimum"), 1, 100, 1000, 1, slider_beam_width_min, nullptr));
sliders.push_back(slider_alloc(machine, _("Beam Width Maximum"), 1, 100, 1000, 1, slider_beam_width_max, nullptr));
sliders.push_back(slider_alloc(machine, _("Beam Intensity Weight"), -1000, 0, 1000, 10, slider_beam_intensity_weight, nullptr));
break;
}
}
#ifdef MAME_DEBUG
// add crosshair adjusters
for (ioport_port &port : machine.ioport().ports())
{
for (ioport_field &field : port.fields())
{
if (field.crosshair_axis() != CROSSHAIR_AXIS_NONE && field.player() == 0)
{
void *param = (void *)&field;
str = string_format(_("Crosshair Scale %1$s"), (field.crosshair_axis() == CROSSHAIR_AXIS_X) ? _("X") : _("Y"));
*tailptr = slider_alloc(machine, str.c_str(), -3000, 1000, 3000, 100, slider_crossscale, param);
tailptr = &(*tailptr)->next;
std::string str = string_format(_("Crosshair Scale %1$s"), (field.crosshair_axis() == CROSSHAIR_AXIS_X) ? _("X") : _("Y"));
sliders.push_back(slider_alloc(machine, str.c_str(), -3000, 1000, 3000, 100, slider_crossscale, (void *)&field));
str = string_format(_("Crosshair Offset %1$s"), (field.crosshair_axis() == CROSSHAIR_AXIS_X) ? _("X") : _("Y"));
*tailptr = slider_alloc(machine, str.c_str(), -3000, 0, 3000, 100, slider_crossoffset, param);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(machine, str.c_str(), -3000, 0, 3000, 100, slider_crossoffset, (void *)&field));
}
}
}
#endif
return listhead;
return sliders;
}

7
src/emu/ui/ui.h
View File

@ -13,6 +13,8 @@
#ifndef __USRINTRF_H__
#define __USRINTRF_H__
#include <vector>
#include "render.h"
#include "moptions.h"
@ -128,6 +130,7 @@ public:
// methods
void initialize(running_machine &machine);
std::vector<slider_state *> slider_init(running_machine &machine);
UINT32 set_handler(ui_callback callback, UINT32 param);
void display_startup_screens(bool first_time);
void set_startup_text(const char *text, bool force);
@ -166,7 +169,7 @@ public:
std::string &game_info_astring(std::string &str);
// slider controls
const slider_state *get_slider_list(void);
std::vector<slider_state *>& get_slider_list(void);
// other
void process_natural_keyboard();
@ -209,7 +212,7 @@ private:
static std::string messagebox_poptext;
static rgb_t messagebox_backcolor;
static slider_state *slider_list;
static std::vector<slider_state *> slider_list;
static slider_state *slider_current;
// text generators

8
src/osd/modules/lib/osdobj_common.cpp
View File

@ -249,7 +249,7 @@ void osd_common_t::register_options()
REGISTER_MODULE(m_mod_man, JOYSTICKINPUT_DINPUT);
REGISTER_MODULE(m_mod_man, JOYSTICKINPUT_XINPUT);
REGISTER_MODULE(m_mod_man, JOYSTICK_NONE);
REGISTER_MODULE(m_mod_man, OUTPUT_NONE);
REGISTER_MODULE(m_mod_man, OUTPUT_CONSOLE);
REGISTER_MODULE(m_mod_man, OUTPUT_NETWORK);
@ -537,9 +537,9 @@ void osd_common_t::customize_input_type_list(simple_list<input_type_entry> &type
// list of OS-dependent slider values.
//-------------------------------------------------
slider_state* osd_common_t::get_slider_list()
std::vector<slider_state*> osd_common_t::get_slider_list()
{
return nullptr;
return m_sliders;
}
//-------------------------------------------------
@ -612,7 +612,7 @@ void osd_common_t::init_subsystems()
select_module_options<netdev_module *>(options(), OSD_NETDEV_PROVIDER);
m_midi = select_module_options<midi_module *>(options(), OSD_MIDI_PROVIDER);
m_output = select_module_options<output_module *>(options(), OSD_OUTPUT_PROVIDER);
machine().output().set_notifier(NULL, output_notifier_callback, this);

4
src/osd/modules/lib/osdobj_common.h
View File

@ -189,7 +189,7 @@ public:
virtual void customize_input_type_list(simple_list<input_type_entry> &typelist) override;
// video overridables
virtual slider_state *get_slider_list() override;
virtual std::vector<slider_state *> get_slider_list() override;
// command option overrides
virtual bool execute_command(const char *command) override;
@ -279,6 +279,8 @@ protected:
input_module* m_lightgun_input;
input_module* m_joystick_input;
output_module* m_output;
std::vector<slider_state *> m_sliders;
private:
std::vector<const char *> m_video_names;
};

7
src/osd/modules/osdwindow.h
View File

@ -189,7 +189,7 @@ public:
virtual int create() = 0;
virtual render_primitive_list *get_primitives() = 0;
virtual slider_state* get_slider_list() { return nullptr; }
virtual std::vector<slider_state*> get_slider_list() { return m_sliders; }
virtual int draw(const int update) = 0;
virtual int xy_to_render_target(const int x, const int y, int *xt, int *yt) { return 0; };
virtual void save() { };
@ -200,9 +200,12 @@ public:
static osd_renderer* make_for_type(int mode, osd_window *window, int extra_flags = FLAG_NONE);
protected:
virtual void build_slider_list() { }
/* Internal flags */
static const int FI_CHANGED = 0x010000;
bool m_sliders_dirty;
bool m_sliders_dirty;
std::vector<slider_state*> m_sliders;
private:
osd_window *m_window;

46
src/osd/modules/render/bgfx/chainmanager.cpp
View File

@ -431,54 +431,36 @@ bool chain_manager::needs_sliders()
return m_screen_count > 0 && m_available_chains.size() > 1;
}
slider_state* chain_manager::get_slider_list()
std::vector<slider_state*> chain_manager::get_slider_list()
{
std::vector<slider_state*> sliders;
if (!needs_sliders())
{
return nullptr;
return sliders;
}
slider_state *listhead = nullptr;
slider_state **tailptr = &listhead;
for (size_t index = 0; index < m_screen_chains.size(); index++)
{
bgfx_chain* chain = m_screen_chains[index];
if (*tailptr == nullptr)
{
*tailptr = m_selection_sliders[index];
}
else
{
(*tailptr)->next = m_selection_sliders[index];
tailptr = &(*tailptr)->next;
}
sliders.push_back(m_selection_sliders[index]);
if (chain == nullptr)
{
continue;
}
std::vector<bgfx_slider*> sliders = chain->sliders();
for (bgfx_slider* slider : sliders)
std::vector<bgfx_slider*> chain_sliders = chain->sliders();
for (bgfx_slider* slider : chain_sliders)
{
if (*tailptr == nullptr)
{
*tailptr = slider->core_slider();
}
else
{
(*tailptr)->next = slider->core_slider();
tailptr = &(*tailptr)->next;
}
sliders.push_back(slider->core_slider());
}
if (sliders.size() > 0)
{
// TODO: Put dividing line
}
}
if (*tailptr != nullptr)
{
(*tailptr)->next = nullptr;
}
return listhead;
return sliders;
}

2
src/osd/modules/render/bgfx/chainmanager.h
View File

@ -41,7 +41,7 @@ public:
bgfx_chain* screen_chain(uint32_t screen);
bgfx_chain* load_chain(std::string name, uint32_t screen_index);
bool has_applicable_chain(uint32_t screen);
slider_state* get_slider_list();
std::vector<slider_state*> get_slider_list();
private:
void load_chains();

54
src/osd/modules/render/d3d/d3dhlsl.cpp
View File

@ -23,6 +23,7 @@
#include "aviio.h"
#include "png.h"
#include "screen.h"
#include "ui/ui.h"
// MAMEOS headers
#include "winmain.h"
@ -37,7 +38,6 @@
// GLOBALS
//============================================================
static slider_state *g_slider_list;
static osd_file::error open_next(renderer_d3d9 *d3d, emu_file &file, const char *templ, const char *extension, int idx);
//============================================================
@ -86,7 +86,7 @@ shaders::shaders() :
shaders::~shaders()
{
for (slider* slider : sliders)
for (slider* slider : internal_sliders)
{
delete slider;
}
@ -400,7 +400,7 @@ void shaders::end_avi_recording()
// shaders::toggle
//============================================================
void shaders::toggle()
void shaders::toggle(std::vector<slider_state*>& sliders)
{
if (master_enable)
{
@ -427,7 +427,7 @@ void shaders::toggle()
if (!initialized)
{
// re-create shader resources after renderer resources
bool failed = create_resources(false);
bool failed = create_resources(false, sliders);
if (failed)
{
master_enable = false;
@ -827,7 +827,7 @@ void shaders::init_fsfx_quad(void *vertbuf)
// shaders::create_resources
//============================================================
int shaders::create_resources(bool reset)
int shaders::create_resources(bool reset, std::vector<slider_state*>& sliders)
{
if (!master_enable || !d3dintf->post_fx_available)
{
@ -1003,7 +1003,8 @@ int shaders::create_resources(bool reset)
initialized = true;
init_slider_list();
std::vector<slider_state*> my_sliders = init_slider_list();
sliders.insert(sliders.end(), my_sliders.begin(), my_sliders.end());
return 0;
}
@ -2103,8 +2104,6 @@ void shaders::delete_resources(bool reset)
}
shadow_bitmap.reset();
g_slider_list = nullptr;
}
@ -2379,10 +2378,6 @@ slider_desc shaders::s_sliders[] =
};
//============================================================
// init_slider_list
//============================================================
void *shaders::get_slider_option(int id, int index)
{
switch (id)
@ -2452,15 +2447,15 @@ void *shaders::get_slider_option(int id, int index)
return nullptr;
}
void shaders::init_slider_list()
std::vector<slider_state*> shaders::init_slider_list()
{
if (!master_enable || !d3dintf->post_fx_available)
{
g_slider_list = nullptr;
}
std::vector<slider_state*> sliders;
slider_state *listhead = nullptr;
slider_state **tailptr = &listhead;
for (slider* slider : internal_sliders)
{
delete slider;
}
internal_sliders.clear();
for (int i = 0; s_sliders[i].name != nullptr; i++)
{
@ -2488,7 +2483,7 @@ void shaders::init_slider_list()
for (int j = 0; j < count; j++)
{
slider* slider_arg = new slider(desc, get_slider_option(desc->id, j), &options->params_dirty);
sliders.push_back(slider_arg);
internal_sliders.push_back(slider_arg);
std::string name = desc->name;
switch (desc->slider_type)
{
@ -2507,13 +2502,12 @@ void shaders::init_slider_list()
default:
break;
}
*tailptr = slider_alloc(*machine, desc->id, name.c_str(), desc->minval, desc->defval, desc->maxval, desc->step, slider_update_trampoline, slider_arg);
tailptr = &(*tailptr)->next;
sliders.push_back(slider_alloc(*machine, desc->id, name.c_str(), desc->minval, desc->defval, desc->maxval, desc->step, slider_update_trampoline, slider_arg));
}
}
}
g_slider_list = listhead;
return sliders;
}
@ -3052,20 +3046,6 @@ ULONG effect::release()
}
//============================================================
// get_slider_list
//============================================================
slider_state *renderer_d3d9::get_slider_list()
{
if (window().m_index > 0)
{
return nullptr;
}
return g_slider_list;
}
// NOTE: The function below is taken directly from src/emu/video.c and should likely be moved into a global helper function.
//-------------------------------------------------
// open_next - open the next non-existing file of

8
src/osd/modules/render/d3d/d3dhlsl.h
View File

@ -303,7 +303,7 @@ public:
void init(d3d_base *d3dintf, running_machine *machine, renderer_d3d9 *renderer);
bool enabled() { return master_enable; }
void toggle();
void toggle(std::vector<slider_state*>& sliders);
bool vector_enabled() { return master_enable && vector_enable; }
d3d_render_target* get_vector_target(render_primitive *prim);
@ -338,11 +338,11 @@ public:
void remove_render_target(int source_width, int source_height, UINT32 screen_index, UINT32 page_index);
void remove_render_target(d3d_render_target *rt);
int create_resources(bool reset);
int create_resources(bool reset, std::vector<slider_state*>& sliders);
void delete_resources(bool reset);
// slider-related functions
void init_slider_list();
std::vector<slider_state*> init_slider_list();
void *get_slider_option(int id, int index = 0);
private:
@ -438,7 +438,7 @@ private:
d3d_render_target * targethead;
cache_target * cachehead;
std::vector<slider*> sliders;
std::vector<slider*> internal_sliders;
static slider_desc s_sliders[];
static hlsl_options last_options; // last used options

2
src/osd/modules/render/drawbgfx.cpp
View File

@ -1118,7 +1118,7 @@ void renderer_bgfx::allocate_buffer(render_primitive *prim, UINT32 blend, bgfx::
}
}
slider_state* renderer_bgfx::get_slider_list()
std::vector<slider_state*> renderer_bgfx::get_slider_list()
{
m_sliders_dirty = false;
return m_chains->get_slider_list();

2
src/osd/modules/render/drawbgfx.h
View File

@ -42,7 +42,7 @@ public:
virtual int create() override;
virtual int draw(const int update) override;
virtual slider_state* get_slider_list() override;
virtual std::vector<slider_state*> get_slider_list() override;
virtual void set_sliders_dirty() override;
#ifdef OSD_SDL

14
src/osd/modules/render/drawd3d.cpp
View File

@ -598,7 +598,8 @@ int renderer_d3d9::pre_window_draw_check()
// if we're restarting the renderer, leave things alone
if (m_restarting)
{
m_shaders->toggle();
m_sliders.clear();
m_shaders->toggle(m_sliders);
m_restarting = false;
}
@ -896,14 +897,16 @@ try_again:
m_shaders = (shaders*)global_alloc_clear<shaders>();
m_shaders->init(d3dintf, &window().machine(), this);
m_sliders_dirty = true;
int failed = m_shaders->create_resources(false);
m_sliders.clear();
int failed = m_shaders->create_resources(false, m_sliders);
if (failed)
{
return failed;
}
m_sliders_dirty = true;
return device_create_resources();
}
@ -1002,6 +1005,7 @@ void renderer_d3d9::device_delete()
if (m_shaders != nullptr)
{
// free our effects
m_sliders.clear();
m_shaders->delete_resources(false);
// delete the HLSL interface
@ -1130,6 +1134,7 @@ int renderer_d3d9::device_test_cooperative()
osd_printf_verbose("Direct3D: resetting device\n");
// free all existing resources and call reset on the device
m_sliders.clear();
m_shaders->delete_resources(true);
device_delete_resources();
result = (*d3dintf->device.reset)(m_device, &m_presentation);
@ -1149,7 +1154,8 @@ int renderer_d3d9::device_test_cooperative()
return 1;
}
if (m_shaders->create_resources(true))
m_sliders.clear();
if (m_shaders->create_resources(true, m_sliders))
{
osd_printf_verbose("Direct3D: failed to recreate HLSL resources for device; failing permanently\n");
device_delete();

1
src/osd/modules/render/drawd3d.h
View File

@ -47,7 +47,6 @@ public:
static void exit();
virtual int create() override;
virtual slider_state* get_slider_list() override;
virtual render_primitive_list *get_primitives() override;
virtual int draw(const int update) override;
virtual void save() override;

2
src/osd/osdepend.h
View File

@ -80,7 +80,7 @@ public:
virtual void customize_input_type_list(simple_list<input_type_entry> &typelist) = 0;
// video overridables
virtual slider_state *get_slider_list() = 0;
virtual std::vector<slider_state *> get_slider_list() = 0;
// font interface
virtual osd_font::ptr font_alloc() = 0;

3
src/osd/sdl/osdsdl.h
View File

@ -141,7 +141,7 @@ public:
virtual void update(bool skip_redraw) override;
// video overridables
virtual slider_state *get_slider_list() override;
virtual std::vector<slider_state *> get_slider_list() override;
// input overridables
virtual void customize_input_type_list(simple_list<input_type_entry> &typelist) override;
@ -174,7 +174,6 @@ private:
sdl_options &m_options;
watchdog *m_watchdog;
slider_state * m_sliders;
};
//============================================================

10
src/osd/sdl/video.cpp
View File

@ -91,16 +91,6 @@ bool sdl_osd_interface::video_init()
return true;
}
//============================================================
// get_slider_list
//============================================================
slider_state *sdl_osd_interface::get_slider_list()
{
return m_sliders;
}
//============================================================
// video_exit
//============================================================

28
src/osd/sdl/window.cpp
View File

@ -308,33 +308,13 @@ void sdl_osd_interface::update_slider_list()
void sdl_osd_interface::build_slider_list()
{
m_sliders = nullptr;
slider_state* full_list = nullptr;
slider_state* curr = nullptr;
m_sliders.clear();
for (sdl_window_info *window = sdl_window_list; window != nullptr; window = window->m_next)
{
// take the sliders of the first window
slider_state* window_sliders = window->renderer().get_slider_list();
if (window_sliders == nullptr)
{
continue;
}
if (full_list == nullptr)
{
full_list = curr = window_sliders;
}
else
{
curr->next = window_sliders;
}
while (curr->next != nullptr) {
curr = curr->next;
}
std::vector<slider_state*> window_sliders = window->renderer().get_slider_list();
m_sliders.insert(m_sliders.end(), window_sliders.begin(), window_sliders.end());
}
m_sliders = full_list;
}
//============================================================

9
src/osd/windows/video.cpp
View File

@ -88,15 +88,6 @@ bool windows_osd_interface::video_init()
return true;
}
//============================================================
// get_slider_list
//============================================================
slider_state *windows_osd_interface::get_slider_list()
{
return m_sliders;
}
//============================================================
// video_exit
//============================================================

27
src/osd/windows/window.cpp
View File

@ -272,33 +272,14 @@ int windows_osd_interface::window_count()
void windows_osd_interface::build_slider_list()
{
m_sliders = nullptr;
slider_state* full_list = nullptr;
slider_state* curr = nullptr;
m_sliders.clear();
for (win_window_info *window = win_window_list; window != nullptr; window = window->m_next)
{
// take the sliders of the first window
slider_state* window_sliders = window->m_renderer->get_slider_list();
if (window_sliders == nullptr)
{
continue;
}
if (full_list == nullptr)
{
full_list = curr = window_sliders;
}
else
{
curr->next = window_sliders;
}
while (curr->next != nullptr) {
curr = curr->next;
}
std::vector<slider_state*> window_sliders = window->m_renderer->get_slider_list();
m_sliders.insert(m_sliders.end(), window_sliders.begin(), window_sliders.end());
}
m_sliders = full_list;
}
//============================================================

1
src/osd/windows/winmain.cpp
View File

@ -506,7 +506,6 @@ static void output_oslog(const running_machine &machine, const char *buffer)
windows_osd_interface::windows_osd_interface(windows_options &options)
: osd_common_t(options)
, m_options(options)
, m_sliders(nullptr)
{
}

3
src/osd/windows/winmain.h
View File

@ -263,8 +263,6 @@ public:
virtual void update(bool skip_redraw) override;
// video overridables
virtual slider_state *get_slider_list() override;
virtual void customize_input_type_list(simple_list<input_type_entry> &typelist) override;
virtual void video_register() override;
@ -294,7 +292,6 @@ private:
virtual void osd_exit() override;
windows_options & m_options;
slider_state * m_sliders;
static const int DEFAULT_FONT_HEIGHT = 200;
};