mirror of
https://github.com/holub/mame
synced 2025-07-06 10:29:38 +03:00
Add runtime screen chain selection, nw
This commit is contained in:
parent
cd243bd4aa
commit
19d51345a1
@ -42,7 +42,7 @@ void ui_menu_sliders::handle()
|
||||
if (menu_event->itemref != nullptr)
|
||||
{
|
||||
const slider_state *slider = (const slider_state *)menu_event->itemref;
|
||||
INT32 curvalue = (*slider->update)(machine(), slider->arg, nullptr, SLIDER_NOCHANGE);
|
||||
INT32 curvalue = (*slider->update)(machine(), slider->arg, slider->id, nullptr, SLIDER_NOCHANGE);
|
||||
INT32 increment = 0;
|
||||
bool alt_pressed = machine().input().code_pressed(KEYCODE_LALT) || machine().input().code_pressed(KEYCODE_RALT);
|
||||
bool ctrl_pressed = machine().input().code_pressed(KEYCODE_LCONTROL) || machine().input().code_pressed(KEYCODE_RCONTROL);
|
||||
@ -104,7 +104,7 @@ void ui_menu_sliders::handle()
|
||||
newvalue = slider->maxval;
|
||||
|
||||
/* update the slider and recompute the menu */
|
||||
(*slider->update)(machine(), slider->arg, nullptr, newvalue);
|
||||
(*slider->update)(machine(), slider->arg, slider->id, nullptr, newvalue);
|
||||
reset(UI_MENU_RESET_REMEMBER_REF);
|
||||
}
|
||||
}
|
||||
@ -142,7 +142,7 @@ void ui_menu_sliders::populate()
|
||||
/* add UI sliders */
|
||||
for (const slider_state *curslider = machine().ui().get_slider_list(); curslider != nullptr; curslider = curslider->next)
|
||||
{
|
||||
INT32 curval = (*curslider->update)(machine(), curslider->arg, &tempstring, SLIDER_NOCHANGE);
|
||||
INT32 curval = (*curslider->update)(machine(), curslider->arg, curslider->id, &tempstring, SLIDER_NOCHANGE);
|
||||
UINT32 flags = 0;
|
||||
if (curval > curslider->minval)
|
||||
flags |= MENU_FLAG_LEFT_ARROW;
|
||||
@ -154,7 +154,7 @@ void ui_menu_sliders::populate()
|
||||
/* add OSD sliders */
|
||||
for (const slider_state *curslider = (slider_state*)machine().osd().get_slider_list(); curslider != nullptr; curslider = curslider->next)
|
||||
{
|
||||
INT32 curval = (*curslider->update)(machine(), curslider->arg, &tempstring, SLIDER_NOCHANGE);
|
||||
INT32 curval = (*curslider->update)(machine(), curslider->arg, curslider->id, &tempstring, SLIDER_NOCHANGE);
|
||||
UINT32 flags = 0;
|
||||
if (curval > curslider->minval)
|
||||
flags |= MENU_FLAG_LEFT_ARROW;
|
||||
@ -184,7 +184,7 @@ void ui_menu_sliders::custom_render(void *selectedref, float top, float bottom,
|
||||
INT32 curval;
|
||||
|
||||
/* determine the current value and text */
|
||||
curval = (*curslider->update)(machine(), curslider->arg, &tempstring, SLIDER_NOCHANGE);
|
||||
curval = (*curslider->update)(machine(), curslider->arg, curslider->id, &tempstring, SLIDER_NOCHANGE);
|
||||
|
||||
/* compute the current and default percentages */
|
||||
percentage = (float)(curval - curslider->minval) / (float)(curslider->maxval - curslider->minval);
|
||||
|
@ -129,30 +129,30 @@ 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, std::string *str, INT32 newval);
|
||||
static INT32 slider_mixervol(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_adjuster(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_overclock(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_refresh(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_brightness(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_contrast(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_gamma(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_xscale(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_yscale(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_xoffset(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_yoffset(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_overxscale(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_overyscale(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_overxoffset(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_overyoffset(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_flicker(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_beam_width_min(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_beam_width_max(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_beam_intensity_weight(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
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);
|
||||
static INT32 slider_overclock(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_refresh(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_brightness(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_contrast(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_gamma(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_xscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_yscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_xoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_yoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_overxscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_overyscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_overxoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_overyoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_flicker(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_beam_width_min(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_beam_width_max(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_beam_intensity_weight(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static std::string slider_get_screen_desc(screen_device &screen);
|
||||
#ifdef MAME_DEBUG
|
||||
static INT32 slider_crossscale(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_crossoffset(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
static INT32 slider_crossscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
static INT32 slider_crossoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
#endif
|
||||
|
||||
|
||||
@ -2056,7 +2056,7 @@ static slider_state *slider_init(running_machine &machine)
|
||||
// slider_volume - global volume slider callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_volume(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_volume(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
if (newval != SLIDER_NOCHANGE)
|
||||
machine.sound().set_attenuation(newval);
|
||||
@ -2071,7 +2071,7 @@ static INT32 slider_volume(running_machine &machine, void *arg, std::string *str
|
||||
// slider callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_mixervol(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_mixervol(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
mixer_input info;
|
||||
if (!machine.sound().indexed_mixer_input((FPTR)arg, info))
|
||||
@ -2093,7 +2093,7 @@ static INT32 slider_mixervol(running_machine &machine, void *arg, std::string *s
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_adjuster(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_adjuster(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
ioport_field *field = (ioport_field *)arg;
|
||||
ioport_field::user_settings settings;
|
||||
@ -2115,7 +2115,7 @@ static INT32 slider_adjuster(running_machine &machine, void *arg, std::string *s
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_overclock(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_overclock(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
device_t *cpu = (device_t *)arg;
|
||||
if (newval != SLIDER_NOCHANGE)
|
||||
@ -2130,7 +2130,7 @@ static INT32 slider_overclock(running_machine &machine, void *arg, std::string *
|
||||
// slider_refresh - refresh rate slider callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_refresh(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_refresh(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
screen_device *screen = reinterpret_cast<screen_device *>(arg);
|
||||
double defrefresh = ATTOSECONDS_TO_HZ(screen->refresh_attoseconds());
|
||||
@ -2155,7 +2155,7 @@ static INT32 slider_refresh(running_machine &machine, void *arg, std::string *st
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_brightness(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_brightness(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
screen_device *screen = reinterpret_cast<screen_device *>(arg);
|
||||
render_container::user_settings settings;
|
||||
@ -2177,7 +2177,7 @@ static INT32 slider_brightness(running_machine &machine, void *arg, std::string
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_contrast(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_contrast(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
screen_device *screen = reinterpret_cast<screen_device *>(arg);
|
||||
render_container::user_settings settings;
|
||||
@ -2198,7 +2198,7 @@ static INT32 slider_contrast(running_machine &machine, void *arg, std::string *s
|
||||
// slider_gamma - screen gamma slider callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_gamma(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_gamma(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
screen_device *screen = reinterpret_cast<screen_device *>(arg);
|
||||
render_container::user_settings settings;
|
||||
@ -2220,7 +2220,7 @@ static INT32 slider_gamma(running_machine &machine, void *arg, std::string *str,
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_xscale(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_xscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
screen_device *screen = reinterpret_cast<screen_device *>(arg);
|
||||
render_container::user_settings settings;
|
||||
@ -2242,7 +2242,7 @@ static INT32 slider_xscale(running_machine &machine, void *arg, std::string *str
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_yscale(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_yscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
screen_device *screen = reinterpret_cast<screen_device *>(arg);
|
||||
render_container::user_settings settings;
|
||||
@ -2264,7 +2264,7 @@ static INT32 slider_yscale(running_machine &machine, void *arg, std::string *str
|
||||
// slider callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_xoffset(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_xoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
screen_device *screen = reinterpret_cast<screen_device *>(arg);
|
||||
render_container::user_settings settings;
|
||||
@ -2286,7 +2286,7 @@ static INT32 slider_xoffset(running_machine &machine, void *arg, std::string *st
|
||||
// slider callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_yoffset(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_yoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
screen_device *screen = reinterpret_cast<screen_device *>(arg);
|
||||
render_container::user_settings settings;
|
||||
@ -2308,7 +2308,7 @@ static INT32 slider_yoffset(running_machine &machine, void *arg, std::string *st
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_overxscale(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_overxscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
laserdisc_device *laserdisc = (laserdisc_device *)arg;
|
||||
laserdisc_overlay_config settings;
|
||||
@ -2330,7 +2330,7 @@ static INT32 slider_overxscale(running_machine &machine, void *arg, std::string
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_overyscale(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_overyscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
laserdisc_device *laserdisc = (laserdisc_device *)arg;
|
||||
laserdisc_overlay_config settings;
|
||||
@ -2352,7 +2352,7 @@ static INT32 slider_overyscale(running_machine &machine, void *arg, std::string
|
||||
// slider callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_overxoffset(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_overxoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
laserdisc_device *laserdisc = (laserdisc_device *)arg;
|
||||
laserdisc_overlay_config settings;
|
||||
@ -2374,7 +2374,7 @@ static INT32 slider_overxoffset(running_machine &machine, void *arg, std::string
|
||||
// slider callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_overyoffset(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_overyoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
laserdisc_device *laserdisc = (laserdisc_device *)arg;
|
||||
laserdisc_overlay_config settings;
|
||||
@ -2396,7 +2396,7 @@ static INT32 slider_overyoffset(running_machine &machine, void *arg, std::string
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_flicker(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_flicker(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
vector_device *vector = nullptr;
|
||||
if (newval != SLIDER_NOCHANGE)
|
||||
@ -2412,7 +2412,7 @@ static INT32 slider_flicker(running_machine &machine, void *arg, std::string *st
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_beam_width_min(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_beam_width_min(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
vector_device *vector = nullptr;
|
||||
if (newval != SLIDER_NOCHANGE)
|
||||
@ -2428,7 +2428,7 @@ static INT32 slider_beam_width_min(running_machine &machine, void *arg, std::str
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_beam_width_max(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_beam_width_max(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
vector_device *vector = nullptr;
|
||||
if (newval != SLIDER_NOCHANGE)
|
||||
@ -2444,7 +2444,7 @@ static INT32 slider_beam_width_max(running_machine &machine, void *arg, std::str
|
||||
// callback
|
||||
//-------------------------------------------------
|
||||
|
||||
static INT32 slider_beam_intensity_weight(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_beam_intensity_weight(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
vector_device *vector = nullptr;
|
||||
if (newval != SLIDER_NOCHANGE)
|
||||
@ -2477,7 +2477,7 @@ static std::string slider_get_screen_desc(screen_device &screen)
|
||||
//-------------------------------------------------
|
||||
|
||||
#ifdef MAME_DEBUG
|
||||
static INT32 slider_crossscale(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_crossscale(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
ioport_field *field = (ioport_field *)arg;
|
||||
|
||||
@ -2496,7 +2496,7 @@ static INT32 slider_crossscale(running_machine &machine, void *arg, std::string
|
||||
//-------------------------------------------------
|
||||
|
||||
#ifdef MAME_DEBUG
|
||||
static INT32 slider_crossoffset(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_crossoffset(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
ioport_field *field = (ioport_field *)arg;
|
||||
|
||||
|
@ -92,7 +92,7 @@ enum
|
||||
|
||||
typedef UINT32 (*ui_callback)(running_machine &, render_container *, UINT32);
|
||||
|
||||
typedef INT32(*slider_update)(running_machine &machine, void *arg, std::string *str, INT32 newval);
|
||||
typedef INT32(*slider_update)(running_machine &machine, void *arg, int id, std::string *str, INT32 newval);
|
||||
|
||||
struct slider_state
|
||||
{
|
||||
|
@ -196,7 +196,6 @@ public:
|
||||
virtual void record() { };
|
||||
virtual void toggle_fsfx() { };
|
||||
virtual bool sliders_dirty() { return m_sliders_dirty; }
|
||||
virtual bool multi_window_sliders() { return false; }
|
||||
|
||||
static osd_renderer* make_for_type(int mode, osd_window *window, int extra_flags = FLAG_NONE);
|
||||
|
||||
|
@ -14,18 +14,23 @@
|
||||
#include "parameter.h"
|
||||
#include "entryuniform.h"
|
||||
#include "texturemanager.h"
|
||||
#include "targetmanager.h"
|
||||
#include "target.h"
|
||||
#include "vertex.h"
|
||||
#include "window.h"
|
||||
|
||||
#include "chain.h"
|
||||
|
||||
bgfx_chain::bgfx_chain(std::string name, std::string author, std::vector<bgfx_slider*> sliders, std::vector<bgfx_parameter*> params, std::vector<bgfx_chain_entry*> entries)
|
||||
bgfx_chain::bgfx_chain(std::string name, std::string author, target_manager& targets, std::vector<bgfx_slider*> sliders, std::vector<bgfx_parameter*> params, std::vector<bgfx_chain_entry*> entries, std::vector<bgfx_target*> target_list, std::uint32_t screen_index)
|
||||
: m_name(name)
|
||||
, m_author(author)
|
||||
, m_targets(targets)
|
||||
, m_sliders(sliders)
|
||||
, m_params(params)
|
||||
, m_entries(entries)
|
||||
, m_target_list(target_list)
|
||||
, m_current_time(0)
|
||||
, m_screen_index(screen_index)
|
||||
{
|
||||
for (bgfx_slider* slider : m_sliders)
|
||||
{
|
||||
@ -47,6 +52,10 @@ bgfx_chain::~bgfx_chain()
|
||||
{
|
||||
delete entry;
|
||||
}
|
||||
for (bgfx_target* target : m_target_list)
|
||||
{
|
||||
m_targets.destroy_target(target->name(), m_screen_index);
|
||||
}
|
||||
}
|
||||
|
||||
void bgfx_chain::process(render_primitive* prim, int view, int screen, texture_manager& textures, osd_window& window, uint64_t blend)
|
||||
|
@ -21,12 +21,14 @@ class render_primitive;
|
||||
class bgfx_slider;
|
||||
class bgfx_parameter;
|
||||
class texture_manager;
|
||||
class target_manager;
|
||||
class bgfx_target;
|
||||
class osd_window;
|
||||
|
||||
class bgfx_chain
|
||||
{
|
||||
public:
|
||||
bgfx_chain(std::string name, std::string author, std::vector<bgfx_slider*> sliders, std::vector<bgfx_parameter*> params, std::vector<bgfx_chain_entry*> entries);
|
||||
bgfx_chain(std::string name, std::string author, target_manager& targets, std::vector<bgfx_slider*> sliders, std::vector<bgfx_parameter*> params, std::vector<bgfx_chain_entry*> entries, std::vector<bgfx_target*> target_list, uint32_t screen_index);
|
||||
~bgfx_chain();
|
||||
|
||||
void process(render_primitive* prim, int view, int screen, texture_manager& textures, osd_window &window, uint64_t blend = 0L);
|
||||
@ -38,11 +40,14 @@ public:
|
||||
private:
|
||||
std::string m_name;
|
||||
std::string m_author;
|
||||
target_manager& m_targets;
|
||||
std::vector<bgfx_slider*> m_sliders;
|
||||
std::vector<bgfx_parameter*> m_params;
|
||||
std::vector<bgfx_chain_entry*> m_entries;
|
||||
std::vector<bgfx_target*> m_target_list;
|
||||
std::map<std::string, bgfx_slider*> m_slider_map;
|
||||
int64_t m_current_time;
|
||||
uint32_t m_screen_index;
|
||||
};
|
||||
|
||||
#endif // __DRAWBGFX_CHAIN__
|
||||
|
@ -9,11 +9,12 @@
|
||||
//
|
||||
//============================================================
|
||||
|
||||
#include <rapidjson/document.h>
|
||||
#include <rapidjson/error/en.h>
|
||||
|
||||
#include "emu.h"
|
||||
#include "window.h"
|
||||
#include "osdcore.h"
|
||||
|
||||
#include <rapidjson/document.h>
|
||||
#include <rapidjson/error/en.h>
|
||||
|
||||
#include <bx/readerwriter.h>
|
||||
#include <bx/crtimpl.h>
|
||||
@ -28,31 +29,68 @@
|
||||
#include "target.h"
|
||||
#include "slider.h"
|
||||
|
||||
#include "ui/ui.h"
|
||||
|
||||
#include "sliderdirtynotifier.h"
|
||||
|
||||
using namespace rapidjson;
|
||||
|
||||
chain_manager::chain_manager(running_machine& machine, osd_options& options, texture_manager& textures, target_manager& targets, effect_manager& effects, uint32_t window_index)
|
||||
const uint32_t chain_manager::CHAIN_NONE = 0;
|
||||
|
||||
chain_manager::chain_manager(running_machine& machine, osd_options& options, texture_manager& textures, target_manager& targets, effect_manager& effects, uint32_t window_index, slider_dirty_notifier& slider_notifier)
|
||||
: m_machine(machine)
|
||||
, m_options(options)
|
||||
, m_textures(textures)
|
||||
, m_targets(targets)
|
||||
, m_effects(effects)
|
||||
, m_window_index(window_index)
|
||||
, m_slider_notifier(slider_notifier)
|
||||
, m_screen_count(0)
|
||||
{
|
||||
load_screen_chains(options.bgfx_screen_chains());
|
||||
find_available_chains(options.bgfx_path());
|
||||
parse_chain_selections(options.bgfx_screen_chains());
|
||||
}
|
||||
|
||||
chain_manager::~chain_manager()
|
||||
{
|
||||
for (std::vector<bgfx_chain*> screen_chains : m_screen_chains)
|
||||
{
|
||||
for (bgfx_chain* chain : screen_chains)
|
||||
{
|
||||
delete chain;
|
||||
}
|
||||
}
|
||||
destroy_chains();
|
||||
}
|
||||
|
||||
bgfx_chain* chain_manager::load_chain(std::string name, running_machine& machine, uint32_t window_index, uint32_t screen_index)
|
||||
void chain_manager::find_available_chains(std::string path)
|
||||
{
|
||||
m_available_chains.clear();
|
||||
m_available_chains.push_back("none");
|
||||
|
||||
osd_directory *directory = osd_opendir((path + "/chains").c_str());
|
||||
if (directory != nullptr)
|
||||
{
|
||||
for (const osd_directory_entry *entry = osd_readdir(directory); entry != nullptr; entry = osd_readdir(directory))
|
||||
{
|
||||
if (entry->type == ENTTYPE_FILE)
|
||||
{
|
||||
std::string name(entry->name);
|
||||
std::string extension(".json");
|
||||
|
||||
// Does the name has at least one character in addition to ".json"?
|
||||
if (name.length() > extension.length())
|
||||
{
|
||||
size_t start = name.length() - extension.length();
|
||||
std::string test_segment = name.substr(start, extension.length());
|
||||
|
||||
// Does it end in .json?
|
||||
if (test_segment == extension)
|
||||
{
|
||||
m_available_chains.push_back(name.substr(0, start));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
osd_closedir(directory);
|
||||
}
|
||||
}
|
||||
|
||||
bgfx_chain* chain_manager::load_chain(std::string name, uint32_t screen_index)
|
||||
{
|
||||
if (name.length() < 5 || (name.compare(name.length() - 5, 5, ".json")!= 0))
|
||||
{
|
||||
@ -87,7 +125,7 @@ bgfx_chain* chain_manager::load_chain(std::string name, running_machine& machine
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bgfx_chain* chain = chain_reader::read_from_value(document, name + ": ", m_options, machine, window_index, screen_index, m_textures, m_targets, m_effects);
|
||||
bgfx_chain* chain = chain_reader::read_from_value(document, name + ": ", m_options, m_machine, m_window_index, screen_index, m_textures, m_targets, m_effects);
|
||||
|
||||
if (chain == nullptr)
|
||||
{
|
||||
@ -98,27 +136,57 @@ bgfx_chain* chain_manager::load_chain(std::string name, running_machine& machine
|
||||
return chain;
|
||||
}
|
||||
|
||||
void chain_manager::load_screen_chains(std::string chain_str)
|
||||
void chain_manager::parse_chain_selections(std::string chain_str)
|
||||
{
|
||||
std::vector<std::vector<std::string>> chain_names = split_option_string(chain_str);
|
||||
load_chains(chain_names);
|
||||
std::vector<std::string> chain_names = split_option_string(chain_str);
|
||||
|
||||
while (m_current_chain.size() != chain_names.size())
|
||||
{
|
||||
m_screen_chains.push_back(nullptr);
|
||||
m_current_chain.push_back(CHAIN_NONE);
|
||||
}
|
||||
|
||||
for (size_t index = 0; index < chain_names.size(); index++)
|
||||
{
|
||||
size_t chain_index = 0;
|
||||
for (chain_index = 0; chain_index < m_available_chains.size(); chain_index++)
|
||||
{
|
||||
if (m_available_chains[chain_index] == chain_names[index])
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (chain_index < m_available_chains.size())
|
||||
{
|
||||
m_current_chain[index] = chain_index;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_current_chain[index] = CHAIN_NONE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::vector<std::string>> chain_manager::split_option_string(std::string chain_str) const
|
||||
std::vector<std::string> chain_manager::split_option_string(std::string chain_str) const
|
||||
{
|
||||
std::vector<std::vector<std::string>> chain_names;
|
||||
chain_names.push_back(std::vector<std::string>());
|
||||
std::vector<std::string> chain_names;
|
||||
|
||||
uint32_t length = chain_str.length();
|
||||
uint32_t win = 0;
|
||||
uint32_t last_start = 0;
|
||||
for (uint32_t i = 0; i < length + 1; i++) {
|
||||
if (i == length || chain_str[i] == ',' || chain_str[i] == ':') {
|
||||
chain_names[win].push_back(chain_str.substr(last_start, i - last_start));
|
||||
for (uint32_t i = 0; i < length + 1; i++)
|
||||
{
|
||||
if (i == length || chain_str[i] == ',' || chain_str[i] == ':')
|
||||
{
|
||||
if (win == m_window_index)
|
||||
{
|
||||
chain_names.push_back(chain_str.substr(last_start, i - last_start));
|
||||
}
|
||||
last_start = i + 1;
|
||||
if (chain_str[i] == ':') {
|
||||
if (chain_str[i] == ':')
|
||||
{
|
||||
win++;
|
||||
chain_names.push_back(std::vector<std::string>());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -126,33 +194,43 @@ std::vector<std::vector<std::string>> chain_manager::split_option_string(std::st
|
||||
return chain_names;
|
||||
}
|
||||
|
||||
void chain_manager::load_chains(std::vector<std::vector<std::string>>& chain_names)
|
||||
void chain_manager::load_chains()
|
||||
{
|
||||
for (uint32_t win = 0; win < chain_names.size(); win++) {
|
||||
m_screen_chains.push_back(std::vector<bgfx_chain*>());
|
||||
if (win != m_window_index) {
|
||||
continue;
|
||||
}
|
||||
for (uint32_t screen = 0; screen < chain_names[win].size(); screen++) {
|
||||
bgfx_chain* chain = load_chain(chain_names[win][screen], m_machine, win, screen);
|
||||
if (chain == nullptr) {
|
||||
chain_names.clear();
|
||||
return;
|
||||
}
|
||||
m_screen_chains[win].push_back(chain);
|
||||
for (size_t chain = 0; chain < m_current_chain.size() && chain < m_screen_chains.size(); chain++)
|
||||
{
|
||||
if (m_current_chain[chain] != CHAIN_NONE)
|
||||
{
|
||||
m_screen_chains[chain] = load_chain(m_available_chains[m_current_chain[chain]], uint32_t(chain));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void chain_manager::destroy_chains()
|
||||
{
|
||||
for (bgfx_chain* chain : m_screen_chains)
|
||||
{
|
||||
if (chain != nullptr)
|
||||
{
|
||||
delete chain;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void chain_manager::reload_chains()
|
||||
{
|
||||
destroy_chains();
|
||||
load_chains();
|
||||
}
|
||||
|
||||
bgfx_chain* chain_manager::screen_chain(uint32_t screen)
|
||||
{
|
||||
if (screen >= m_screen_chains[m_window_index].size())
|
||||
if (screen >= m_screen_chains.size())
|
||||
{
|
||||
return m_screen_chains[m_window_index][m_screen_chains[m_window_index].size() - 1];
|
||||
return m_screen_chains[m_screen_chains.size() - 1];
|
||||
}
|
||||
else
|
||||
{
|
||||
return m_screen_chains[m_window_index][screen];
|
||||
return m_screen_chains[screen];
|
||||
}
|
||||
}
|
||||
|
||||
@ -184,16 +262,21 @@ std::vector<render_primitive*> chain_manager::count_screens(render_primitive* pr
|
||||
|
||||
int screen_count = 0;
|
||||
std::vector<void*> bases;
|
||||
while (prim != nullptr) {
|
||||
if (PRIMFLAG_GET_SCREENTEX(prim->flags)) {
|
||||
while (prim != nullptr)
|
||||
{
|
||||
if (PRIMFLAG_GET_SCREENTEX(prim->flags))
|
||||
{
|
||||
bool found = false;
|
||||
for (void* base : bases) {
|
||||
if (base == prim->texture.base) {
|
||||
for (void* base : bases)
|
||||
{
|
||||
if (base == prim->texture.base)
|
||||
{
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
if (!found)
|
||||
{
|
||||
screen_count++;
|
||||
screens.push_back(prim);
|
||||
bases.push_back(prim->texture.base);
|
||||
@ -202,43 +285,115 @@ std::vector<render_primitive*> chain_manager::count_screens(render_primitive* pr
|
||||
prim = prim->next();
|
||||
}
|
||||
|
||||
const uint32_t available_chains = m_screen_chains[m_window_index].size();
|
||||
if (screen_count >= available_chains)
|
||||
if (screen_count > 0)
|
||||
{
|
||||
screen_count = available_chains;
|
||||
}
|
||||
|
||||
if (screen_count > 0) {
|
||||
update_screen_count(screen_count);
|
||||
m_targets.update_screen_count(screen_count);
|
||||
}
|
||||
|
||||
return screens;
|
||||
}
|
||||
|
||||
uint32_t chain_manager::handle_screen_chains(uint32_t view, render_primitive *starting_prim, osd_window& window) {
|
||||
if (m_screen_chains.size() <= m_window_index || m_screen_chains[m_window_index].size() == 0) {
|
||||
return 0;
|
||||
void chain_manager::update_screen_count(uint32_t screen_count)
|
||||
{
|
||||
if (screen_count != m_screen_count)
|
||||
{
|
||||
m_slider_notifier.set_sliders_dirty();
|
||||
m_screen_count = screen_count;
|
||||
|
||||
// Ensure we have one screen chain entry per screen
|
||||
while (m_screen_chains.size() < m_screen_count)
|
||||
{
|
||||
m_screen_chains.push_back(nullptr);
|
||||
m_current_chain.push_back(CHAIN_NONE);
|
||||
}
|
||||
|
||||
// Ensure we have a screen chain selection slider per screen
|
||||
while (m_selection_sliders.size() < m_screen_count)
|
||||
{
|
||||
create_selection_slider(m_selection_sliders.size());
|
||||
}
|
||||
|
||||
load_chains();
|
||||
}
|
||||
}
|
||||
|
||||
static INT32 update_trampoline(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
if (arg != nullptr)
|
||||
{
|
||||
return reinterpret_cast<chain_manager*>(arg)->chain_changed(id, str, newval);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t chain_manager::chain_changed(int32_t id, std::string *str, int32_t newval)
|
||||
{
|
||||
if (newval != SLIDER_NOCHANGE)
|
||||
{
|
||||
m_current_chain[id] = newval;
|
||||
|
||||
// Reload chains
|
||||
load_chains();
|
||||
|
||||
m_slider_notifier.set_sliders_dirty();
|
||||
}
|
||||
|
||||
if (str != nullptr)
|
||||
{
|
||||
*str = string_format("%s", m_available_chains[m_current_chain[id]].c_str());
|
||||
}
|
||||
|
||||
return m_current_chain[id];
|
||||
}
|
||||
|
||||
void chain_manager::create_selection_slider(uint32_t screen_index)
|
||||
{
|
||||
if (screen_index < m_selection_sliders.size())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
std::string description = "Window " + std::to_string(m_window_index) + ", Screen " + std::to_string(screen_index) + " Effect:";
|
||||
size_t size = sizeof(slider_state) + description.length();
|
||||
slider_state *state = reinterpret_cast<slider_state *>(auto_alloc_array_clear(m_machine, UINT8, size));
|
||||
|
||||
state->minval = 0;
|
||||
state->defval = m_current_chain[screen_index];
|
||||
state->maxval = m_available_chains.size() - 1;
|
||||
state->incval = 1;
|
||||
state->update = update_trampoline;
|
||||
state->arg = this;
|
||||
state->id = screen_index;
|
||||
strcpy(state->description, description.c_str());
|
||||
|
||||
m_selection_sliders.push_back(state);
|
||||
}
|
||||
|
||||
uint32_t chain_manager::handle_screen_chains(uint32_t view, render_primitive *starting_prim, osd_window& window)
|
||||
{
|
||||
std::vector<render_primitive*> screens = count_screens(starting_prim);
|
||||
|
||||
if (screens.size() == 0) {
|
||||
if (screens.size() == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
const uint32_t available_chains = m_screen_chains[m_window_index].size();
|
||||
|
||||
// Process each screen as necessary
|
||||
uint32_t used_views = 0;
|
||||
int screen_index = 0;
|
||||
for (render_primitive* prim : screens) {
|
||||
if (screen_index >= available_chains) {
|
||||
break;
|
||||
uint32_t screen_index = 0;
|
||||
for (render_primitive* prim : screens)
|
||||
{
|
||||
if (m_current_chain[screen_index] == CHAIN_NONE)
|
||||
{
|
||||
screen_index++;
|
||||
continue;
|
||||
}
|
||||
|
||||
uint16_t screen_width(floor((prim->bounds.x1 - prim->bounds.x0) + 0.5f));
|
||||
uint16_t screen_height(floor((prim->bounds.y1 - prim->bounds.y0) + 0.5f));
|
||||
if (window.swap_xy()) {
|
||||
if (window.swap_xy())
|
||||
{
|
||||
std::swap(screen_width, screen_height);
|
||||
}
|
||||
|
||||
@ -254,34 +409,64 @@ uint32_t chain_manager::handle_screen_chains(uint32_t view, render_primitive *st
|
||||
return used_views;
|
||||
}
|
||||
|
||||
bool chain_manager::has_applicable_pass(uint32_t screen)
|
||||
bool chain_manager::has_applicable_chain(uint32_t screen)
|
||||
{
|
||||
return m_screen_chains.size() > m_window_index && screen < m_screen_chains[m_window_index].size();
|
||||
return screen < m_screen_count && m_current_chain[screen] != CHAIN_NONE && m_screen_chains[screen] != nullptr;
|
||||
}
|
||||
|
||||
bool chain_manager::needs_sliders()
|
||||
{
|
||||
return m_screen_count > 0 && m_available_chains.size() > 1;
|
||||
}
|
||||
|
||||
slider_state* chain_manager::get_slider_list()
|
||||
{
|
||||
if (m_screen_chains.size() <= m_window_index || m_screen_chains[m_window_index].size() == 0) {
|
||||
if (!needs_sliders())
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
slider_state *listhead = nullptr;
|
||||
slider_state **tailptr = &listhead;
|
||||
for (std::vector<bgfx_chain*> screen : m_screen_chains) {
|
||||
for (bgfx_chain* chain : screen) {
|
||||
std::vector<bgfx_slider*> sliders = chain->sliders();
|
||||
for (bgfx_slider* slider : sliders) {
|
||||
if (*tailptr == nullptr) {
|
||||
*tailptr = slider->core_slider();
|
||||
} else {
|
||||
(*tailptr)->next = slider->core_slider();
|
||||
tailptr = &(*tailptr)->next;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
if (chain == nullptr)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
std::vector<bgfx_slider*> sliders = chain->sliders();
|
||||
for (bgfx_slider* slider : sliders)
|
||||
{
|
||||
if (*tailptr == nullptr)
|
||||
{
|
||||
*tailptr = slider->core_slider();
|
||||
}
|
||||
else
|
||||
{
|
||||
(*tailptr)->next = slider->core_slider();
|
||||
tailptr = &(*tailptr)->next;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (*tailptr != nullptr) {
|
||||
|
||||
if (*tailptr != nullptr)
|
||||
{
|
||||
(*tailptr)->next = nullptr;
|
||||
}
|
||||
|
||||
return listhead;
|
||||
}
|
@ -23,37 +23,56 @@
|
||||
|
||||
class running_machine;
|
||||
class osd_window;
|
||||
class slider_dirty_notifier;
|
||||
|
||||
class bgfx_chain;
|
||||
class bgfx_slider;
|
||||
|
||||
class chain_manager {
|
||||
class chain_manager
|
||||
{
|
||||
public:
|
||||
chain_manager(running_machine& machine, osd_options& options, texture_manager& textures, target_manager& targets, effect_manager& effects, uint32_t window_index);
|
||||
chain_manager(running_machine& machine, osd_options& options, texture_manager& textures, target_manager& targets, effect_manager& effects, uint32_t window_index, slider_dirty_notifier& slider_notifier);
|
||||
~chain_manager();
|
||||
|
||||
uint32_t handle_screen_chains(uint32_t view, render_primitive *starting_prim, osd_window& window);
|
||||
|
||||
int32_t chain_changed(int32_t index, std::string *str, int32_t newval);
|
||||
|
||||
// Getters
|
||||
bgfx_chain* screen_chain(uint32_t screen);
|
||||
bgfx_chain* load_chain(std::string name, running_machine& machine, uint32_t window_index, uint32_t screen_index);
|
||||
bool has_applicable_pass(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();
|
||||
|
||||
private:
|
||||
void load_screen_chains(std::string chain_str);
|
||||
std::vector<std::vector<std::string>> split_option_string(std::string chain_str) const;
|
||||
void load_chains(std::vector<std::vector<std::string>>& chains);
|
||||
|
||||
void load_chains();
|
||||
void destroy_chains();
|
||||
void reload_chains();
|
||||
|
||||
void find_available_chains(std::string path);
|
||||
void parse_chain_selections(std::string chain_str);
|
||||
std::vector<std::string> split_option_string(std::string chain_str) const;
|
||||
|
||||
void update_screen_count(uint32_t screen_count);
|
||||
void create_selection_slider(uint32_t screen_index);
|
||||
bool needs_sliders();
|
||||
|
||||
std::vector<render_primitive*> count_screens(render_primitive* prim);
|
||||
void process_screen_quad(uint32_t view, uint32_t screen, render_primitive* prim, osd_window &window);
|
||||
|
||||
running_machine& m_machine;
|
||||
osd_options& m_options;
|
||||
texture_manager& m_textures;
|
||||
target_manager& m_targets;
|
||||
effect_manager& m_effects;
|
||||
uint32_t m_window_index;
|
||||
std::vector<std::vector<bgfx_chain*>> m_screen_chains;
|
||||
running_machine& m_machine;
|
||||
osd_options& m_options;
|
||||
texture_manager& m_textures;
|
||||
target_manager& m_targets;
|
||||
effect_manager& m_effects;
|
||||
uint32_t m_window_index;
|
||||
slider_dirty_notifier& m_slider_notifier;
|
||||
uint32_t m_screen_count;
|
||||
std::vector<std::string> m_available_chains;
|
||||
std::vector<bgfx_chain*> m_screen_chains;
|
||||
std::vector<slider_state*> m_selection_sliders;
|
||||
std::vector<int32_t> m_current_chain;
|
||||
|
||||
static const uint32_t CHAIN_NONE;
|
||||
};
|
||||
|
||||
#endif // __DRAWBGFX_CHAIN_MANAGER__
|
||||
|
@ -84,16 +84,19 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix
|
||||
}
|
||||
|
||||
// Create targets
|
||||
std::vector<bgfx_target*> target_list;
|
||||
if (value.HasMember("targets"))
|
||||
{
|
||||
const Value& target_array = value["targets"];
|
||||
// TODO: Move into its own reader
|
||||
for (UINT32 i = 0; i < target_array.Size(); i++)
|
||||
{
|
||||
if (!target_reader::read_from_value(target_array[i], prefix + "targets[" + std::to_string(i) + "]: ", targets, options, screen_index))
|
||||
bgfx_target* target = target_reader::read_from_value(target_array[i], prefix + "targets[" + std::to_string(i) + "]: ", targets, options, screen_index);
|
||||
if (target == nullptr)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
target_list.push_back(target);
|
||||
}
|
||||
}
|
||||
|
||||
@ -113,7 +116,7 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix
|
||||
}
|
||||
}
|
||||
|
||||
return new bgfx_chain(name, author, sliders, parameters, entries);
|
||||
return new bgfx_chain(name, author, targets, sliders, parameters, entries, target_list, screen_index);
|
||||
}
|
||||
|
||||
bool chain_reader::validate_parameters(const Value& value, std::string prefix)
|
||||
|
@ -1,9 +1,5 @@
|
||||
vec4 v_color0 : COLOR0 = vec4(1.0, 0.0, 0.0, 1.0);
|
||||
vec2 v_texcoord0 : TEXCOORD0 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord1 : TEXCOORD1 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord2 : TEXCOORD2 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord3 : TEXCOORD3 = vec2(0.0, 0.0);
|
||||
vec3 v_pos : TEXCOORD3 = vec3(0.0, 0.0, 0.0);
|
||||
|
||||
vec3 a_position : POSITION;
|
||||
vec4 a_color0 : COLOR0;
|
||||
|
@ -0,0 +1,9 @@
|
||||
vec4 v_color0 : COLOR0 = vec4(1.0, 0.0, 0.0, 1.0);
|
||||
vec2 v_texcoord0 : TEXCOORD0 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord1 : TEXCOORD1 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord2 : TEXCOORD2 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord3 : TEXCOORD3 = vec2(0.0, 0.0);
|
||||
|
||||
vec3 a_position : POSITION;
|
||||
vec4 a_color0 : COLOR0;
|
||||
vec2 a_texcoord0 : TEXCOORD0;
|
@ -0,0 +1,14 @@
|
||||
$input v_color0, v_texcoord0
|
||||
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Dario Manesku
|
||||
|
||||
#include "common.sh"
|
||||
|
||||
// Samplers
|
||||
SAMPLER2D(s_tex, 0);
|
||||
|
||||
void main()
|
||||
{
|
||||
gl_FragColor = texture2D(s_tex, v_texcoord0) * v_color0;
|
||||
}
|
@ -0,0 +1,6 @@
|
||||
vec4 v_color0 : COLOR0 = vec4(1.0, 0.0, 0.0, 1.0);
|
||||
vec2 v_texcoord0 : TEXCOORD0 = vec2(0.0, 0.0);
|
||||
|
||||
vec3 a_position : POSITION;
|
||||
vec4 a_color0 : COLOR0;
|
||||
vec2 a_texcoord0 : TEXCOORD0;
|
@ -0,0 +1,14 @@
|
||||
$input a_position, a_texcoord0, a_color0
|
||||
$output v_texcoord0, v_color0
|
||||
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Dario Manesku
|
||||
|
||||
#include "common.sh"
|
||||
|
||||
void main()
|
||||
{
|
||||
gl_Position = mul(u_viewProj, vec4(a_position.xy, 0.0, 1.0));
|
||||
v_texcoord0 = a_texcoord0;
|
||||
v_color0 = a_color0;
|
||||
}
|
@ -1,9 +1,5 @@
|
||||
vec4 v_color0 : COLOR0 = vec4(1.0, 0.0, 0.0, 1.0);
|
||||
vec2 v_texcoord0 : TEXCOORD0 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord1 : TEXCOORD1 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord2 : TEXCOORD2 = vec2(0.0, 0.0);
|
||||
vec2 v_texcoord3 : TEXCOORD3 = vec2(0.0, 0.0);
|
||||
vec3 v_pos : TEXCOORD3 = vec3(0.0, 0.0, 0.0);
|
||||
|
||||
vec3 a_position : POSITION;
|
||||
vec4 a_color0 : COLOR0;
|
||||
|
@ -42,7 +42,7 @@ bgfx_slider::~bgfx_slider()
|
||||
{
|
||||
}
|
||||
|
||||
static INT32 update_trampoline(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 update_trampoline(running_machine &machine, void *arg, int /*id*/, std::string *str, INT32 newval)
|
||||
{
|
||||
if (arg != nullptr)
|
||||
{
|
||||
@ -62,7 +62,7 @@ slider_state* bgfx_slider::create_core_slider(running_machine& machine)
|
||||
state->incval = m_step;
|
||||
state->update = update_trampoline;
|
||||
state->arg = this;
|
||||
state->id = 0; // fixme
|
||||
state->id = 0;
|
||||
strcpy(state->description, m_description.c_str());
|
||||
|
||||
return state;
|
||||
|
@ -48,14 +48,26 @@ target_manager::~target_manager()
|
||||
bgfx_target* target_manager::create_target(std::string name, bgfx::TextureFormat::Enum format, uint16_t width, uint16_t height, uint32_t style, bool double_buffer, bool filter, uint16_t scale, uint32_t screen)
|
||||
{
|
||||
bgfx_target* target = new bgfx_target(name, format, width, height, style, double_buffer, filter, scale, screen);
|
||||
std::string full_name = name + std::to_string(screen);
|
||||
|
||||
m_targets[name + std::to_string(screen)] = target;
|
||||
m_targets[full_name] = target;
|
||||
|
||||
m_textures.add_provider(name + std::to_string(screen), target);
|
||||
m_textures.add_provider(full_name, target);
|
||||
|
||||
return target;
|
||||
}
|
||||
|
||||
void target_manager::destroy_target(std::string name, uint32_t screen)
|
||||
{
|
||||
std::string full_name = name + std::to_string(screen);
|
||||
if (m_targets[full_name] != nullptr)
|
||||
{
|
||||
delete m_targets[full_name];
|
||||
m_targets[full_name] = nullptr;
|
||||
m_textures.remove_provider(full_name);
|
||||
}
|
||||
}
|
||||
|
||||
bgfx_target* target_manager::create_backbuffer(void *handle, uint16_t width, uint16_t height)
|
||||
{
|
||||
bgfx_target* target = new bgfx_target(handle, width, height);
|
||||
@ -161,3 +173,15 @@ void target_manager::create_target_if_nonexistent(uint32_t screen, std::string n
|
||||
|
||||
create_target(name, bgfx::TextureFormat::RGBA8, width, height, style, double_buffered, filter, 1, screen);
|
||||
}
|
||||
|
||||
uint16_t target_manager::width(uint32_t style, uint32_t screen)
|
||||
{
|
||||
std::vector<osd_dim>& sizes = style == TARGET_STYLE_GUEST ? m_guest_dims : m_native_dims;
|
||||
return screen < sizes.size() ? sizes[screen].width() : 0;
|
||||
}
|
||||
|
||||
uint16_t target_manager::height(uint32_t style, uint32_t screen)
|
||||
{
|
||||
std::vector<osd_dim>& sizes = style == TARGET_STYLE_GUEST ? m_guest_dims : m_native_dims;
|
||||
return screen < sizes.size() ? sizes[screen].height() : 0;
|
||||
}
|
||||
|
@ -31,6 +31,7 @@ public:
|
||||
~target_manager();
|
||||
|
||||
bgfx_target* create_target(std::string name, bgfx::TextureFormat::Enum format, uint16_t width, uint16_t height, uint32_t style, bool double_buffer, bool filter, uint16_t scale, uint32_t screen);
|
||||
void destroy_target(std::string name, uint32_t screen);
|
||||
bgfx_target* create_backbuffer(void *handle, uint16_t width, uint16_t height);
|
||||
|
||||
void update_target_sizes(uint32_t screen, uint16_t width, uint16_t height, uint32_t style);
|
||||
@ -38,6 +39,8 @@ public:
|
||||
|
||||
// Getters
|
||||
bgfx_target* target(uint32_t screen, std::string name);
|
||||
uint16_t width(uint32_t style, uint32_t screen);
|
||||
uint16_t height(uint32_t style, uint32_t screen);
|
||||
|
||||
private:
|
||||
void rebuild_targets(uint32_t screen, uint32_t style);
|
||||
|
@ -21,11 +21,11 @@ const target_reader::string_to_enum target_reader::STYLE_NAMES[target_reader::ST
|
||||
{ "custom", TARGET_STYLE_CUSTOM }
|
||||
};
|
||||
|
||||
bool target_reader::read_from_value(const Value& value, std::string prefix, target_manager& targets, osd_options& options, uint32_t screen_index)
|
||||
bgfx_target* target_reader::read_from_value(const Value& value, std::string prefix, target_manager& targets, osd_options& options, uint32_t screen_index)
|
||||
{
|
||||
if (!validate_parameters(value, prefix))
|
||||
{
|
||||
return false;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::string target_name = value["name"].GetString();
|
||||
@ -43,21 +43,24 @@ bool target_reader::read_from_value(const Value& value, std::string prefix, targ
|
||||
switch (mode)
|
||||
{
|
||||
case TARGET_STYLE_GUEST:
|
||||
break;
|
||||
width = targets.width(TARGET_STYLE_GUEST, screen_index);
|
||||
height = targets.height(TARGET_STYLE_GUEST, screen_index);
|
||||
break;
|
||||
case TARGET_STYLE_NATIVE:
|
||||
break;
|
||||
width = targets.width(TARGET_STYLE_NATIVE, screen_index);
|
||||
height = targets.height(TARGET_STYLE_NATIVE, screen_index);
|
||||
break;
|
||||
case TARGET_STYLE_CUSTOM:
|
||||
if (!READER_CHECK(value.HasMember("width"), (prefix + "Target '" + target_name + "': Must have numeric value 'width'\n").c_str())) return false;
|
||||
if (!READER_CHECK(value["width"].IsNumber(), (prefix + "Target '" + target_name + "': Value 'width' must be a number\n").c_str())) return false;
|
||||
if (!READER_CHECK(value.HasMember("height"), (prefix + "Target '" + target_name + "': Must have numeric value 'height'\n").c_str())) return false;
|
||||
if (!READER_CHECK(value["height"].IsNumber(), (prefix + "Target '" + target_name + "': Value 'height' must be a number\n").c_str())) return false;
|
||||
if (!READER_CHECK(value.HasMember("width"), (prefix + "Target '" + target_name + "': Must have numeric value 'width'\n").c_str())) return nullptr;
|
||||
if (!READER_CHECK(value["width"].IsNumber(), (prefix + "Target '" + target_name + "': Value 'width' must be a number\n").c_str())) return nullptr;
|
||||
if (!READER_CHECK(value.HasMember("height"), (prefix + "Target '" + target_name + "': Must have numeric value 'height'\n").c_str())) return nullptr;
|
||||
if (!READER_CHECK(value["height"].IsNumber(), (prefix + "Target '" + target_name + "': Value 'height' must be a number\n").c_str())) return nullptr;
|
||||
width = uint16_t(value["width"].GetDouble());
|
||||
height = uint16_t(value["height"].GetDouble());
|
||||
break;
|
||||
}
|
||||
|
||||
targets.create_target(target_name, bgfx::TextureFormat::RGBA8, width, height, mode, double_buffer, bilinear, scale, screen_index);
|
||||
return true;
|
||||
return targets.create_target(target_name, bgfx::TextureFormat::RGBA8, width, height, mode, double_buffer, bilinear, scale, screen_index);
|
||||
}
|
||||
|
||||
bool target_reader::validate_parameters(const Value& value, std::string prefix)
|
||||
|
@ -15,13 +15,14 @@
|
||||
|
||||
#include "statereader.h"
|
||||
|
||||
class bgfx_target;
|
||||
class target_manager;
|
||||
class osd_options;
|
||||
|
||||
class target_reader : public state_reader
|
||||
{
|
||||
public:
|
||||
static bool read_from_value(const Value& value, std::string prefix, target_manager& targets, osd_options& options, uint32_t screen_index);
|
||||
static bgfx_target* read_from_value(const Value& value, std::string prefix, target_manager& targets, osd_options& options, uint32_t screen_index);
|
||||
|
||||
private:
|
||||
static bool validate_parameters(const Value& value, std::string prefix);
|
||||
|
@ -62,23 +62,25 @@ bgfx_texture* texture_manager::create_png_texture(std::string path, std::string
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
uint8_t *texture_data = new uint8_t[bitmap.width() * bitmap.height() * 4];
|
||||
uint8_t *data = new uint8_t[bitmap.width() * bitmap.height() * 4];
|
||||
UINT32 *data32 = reinterpret_cast<UINT32 *>(data);
|
||||
|
||||
uint32_t width = bitmap.width();
|
||||
uint32_t height = bitmap.height();
|
||||
uint32_t rowpixels = bitmap.rowpixels();
|
||||
void *base = bitmap.raw_pixptr(0);
|
||||
for (int y = 0; y < height; y++) {
|
||||
copy_util::copyline_argb32(reinterpret_cast<UINT32 *>(texture_data) + y * width, reinterpret_cast<UINT32 *>(base) + y * rowpixels, width, nullptr);
|
||||
const uint32_t width = bitmap.width();
|
||||
const uint32_t height = bitmap.height();
|
||||
const uint32_t rowpixels = bitmap.rowpixels();
|
||||
UINT32* base = reinterpret_cast<UINT32 *>(bitmap.raw_pixptr(0));
|
||||
for (int y = 0; y < height; y++)
|
||||
{
|
||||
copy_util::copyline_argb32(data32 + y * width, base + y * rowpixels, width, nullptr);
|
||||
}
|
||||
|
||||
if (screen >= 0)
|
||||
{
|
||||
texture_name += std::to_string(screen);
|
||||
}
|
||||
bgfx_texture* texture = create_texture(texture_name, bgfx::TextureFormat::RGBA8, width, height, texture_data, flags);
|
||||
bgfx_texture* texture = create_texture(texture_name, bgfx::TextureFormat::RGBA8, width, height, data, flags);
|
||||
|
||||
delete[] texture_data;
|
||||
delete [] data;
|
||||
|
||||
return texture;
|
||||
}
|
||||
@ -106,3 +108,16 @@ bgfx_texture_handle_provider* texture_manager::provider(std::string name)
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void texture_manager::remove_provider(std::string name, bool delete_provider)
|
||||
{
|
||||
if (provider(name) != nullptr)
|
||||
{
|
||||
if (delete_provider)
|
||||
{
|
||||
delete m_textures[name];
|
||||
}
|
||||
m_textures[name] = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -30,6 +30,7 @@ public:
|
||||
bgfx_texture* create_texture(std::string name, bgfx::TextureFormat::Enum format, uint32_t width, uint32_t height, void* data = nullptr, uint32_t flags = BGFX_TEXTURE_U_CLAMP | BGFX_TEXTURE_V_CLAMP);
|
||||
bgfx_texture* create_png_texture(std::string path, std::string file_name, std::string texture_name, uint32_t flags = BGFX_TEXTURE_U_CLAMP | BGFX_TEXTURE_V_CLAMP, uint32_t screen = -1);
|
||||
void add_provider(std::string name, bgfx_texture_handle_provider* texture);
|
||||
void remove_provider(std::string name, bool delete_provider = false);
|
||||
|
||||
// Getters
|
||||
bgfx::TextureHandle handle(std::string name);
|
||||
|
@ -2226,7 +2226,7 @@ INT32 slider::update(std::string *str, INT32 newval)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static INT32 slider_update_trampoline(running_machine &machine, void *arg, std::string *str, INT32 newval)
|
||||
static INT32 slider_update_trampoline(running_machine &machine, void *arg, int id, std::string *str, INT32 newval)
|
||||
{
|
||||
if (arg != nullptr)
|
||||
{
|
||||
|
@ -190,7 +190,7 @@ int renderer_bgfx::create()
|
||||
m_screen_effect[2] = m_effects->effect("screen_multiply");
|
||||
m_screen_effect[3] = m_effects->effect("screen_add");
|
||||
|
||||
m_chains = new chain_manager(window().machine(), options, *m_textures, *m_targets, *m_effects, window().m_index);
|
||||
m_chains = new chain_manager(window().machine(), options, *m_textures, *m_targets, *m_effects, window().m_index, *this);
|
||||
m_sliders_dirty = true;
|
||||
|
||||
uint32_t flags = BGFX_TEXTURE_U_CLAMP | BGFX_TEXTURE_V_CLAMP | BGFX_TEXTURE_MIN_POINT | BGFX_TEXTURE_MAG_POINT | BGFX_TEXTURE_MIP_POINT;
|
||||
@ -907,7 +907,7 @@ renderer_bgfx::buffer_status renderer_bgfx::buffer_primitives(bool atlas_valid,
|
||||
return BUFFER_PRE_FLUSH;
|
||||
}
|
||||
|
||||
if (PRIMFLAG_GET_SCREENTEX((*prim)->flags) && m_chains->has_applicable_pass(screen))
|
||||
if (PRIMFLAG_GET_SCREENTEX((*prim)->flags) && m_chains->has_applicable_chain(screen))
|
||||
{
|
||||
#if SCENE_VIEW
|
||||
setup_view(s_current_view, true);
|
||||
@ -1123,3 +1123,8 @@ slider_state* renderer_bgfx::get_slider_list()
|
||||
m_sliders_dirty = false;
|
||||
return m_chains->get_slider_list();
|
||||
}
|
||||
|
||||
void renderer_bgfx::set_sliders_dirty()
|
||||
{
|
||||
m_sliders_dirty = true;
|
||||
}
|
@ -12,6 +12,7 @@
|
||||
|
||||
#include "binpacker.h"
|
||||
#include "bgfx/vertex.h"
|
||||
#include "sliderdirtynotifier.h"
|
||||
|
||||
class texture_manager;
|
||||
class target_manager;
|
||||
@ -24,7 +25,7 @@ class bgfx_target;
|
||||
class bgfx_chain;
|
||||
|
||||
/* sdl_info is the information about SDL for the current screen */
|
||||
class renderer_bgfx : public osd_renderer
|
||||
class renderer_bgfx : public osd_renderer, public slider_dirty_notifier
|
||||
{
|
||||
public:
|
||||
renderer_bgfx(osd_window *w)
|
||||
@ -39,9 +40,10 @@ public:
|
||||
static void exit();
|
||||
|
||||
virtual int create() override;
|
||||
virtual slider_state* get_slider_list() override;
|
||||
virtual bool multi_window_sliders() override { return true; }
|
||||
virtual int draw(const int update) override;
|
||||
virtual int draw(const int update) override;
|
||||
|
||||
virtual slider_state* get_slider_list() override;
|
||||
virtual void set_sliders_dirty() override;
|
||||
|
||||
#ifdef OSD_SDL
|
||||
virtual int xy_to_render_target(const int x, const int y, int *xt, int *yt) override;
|
||||
|
22
src/osd/modules/render/sliderdirtynotifier.h
Normal file
22
src/osd/modules/render/sliderdirtynotifier.h
Normal file
@ -0,0 +1,22 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Ryan Holtz
|
||||
//====================================================================
|
||||
//
|
||||
// sliderdirtynotifier.cpp - Interface for a slider-changed callback
|
||||
//
|
||||
//====================================================================
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef __RENDER_SLIDER_DIRTY_NOTIFIER__
|
||||
#define __RENDER_SLIDER_DIRTY_NOTIFIER__
|
||||
|
||||
class slider_dirty_notifier
|
||||
{
|
||||
public:
|
||||
virtual ~slider_dirty_notifier() { }
|
||||
|
||||
virtual void set_sliders_dirty() = 0;
|
||||
};
|
||||
|
||||
#endif // __RENDER_SLIDER_DIRTY_NOTIFIER__
|
Loading…
Reference in New Issue
Block a user