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

Add runtime screen chain selection, nw

Browse Source
This commit is contained in:
therealmogminer@gmail.com 2016-04-09 19:15:26 +02:00
parent cd243bd4aa
commit 19d51345a1
46 changed files with 518 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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);

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

@ -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;

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

@ -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
{

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

@ -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);

11
src/osd/modules/render/bgfx/chain.cpp
View File

@ -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)

7
src/osd/modules/render/bgfx/chain.h
View File

@ -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__

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

@ -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;
}

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

@ -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__

7
src/osd/modules/render/bgfx/chainreader.cpp
View File

@ -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)

4
src/osd/modules/render/bgfx/shaders/chains/default/varying.def.sc
View File

@ -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
src/osd/modules/render/bgfx/shaders/fs_blit.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_blit.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_color.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_color.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_deconverge.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_deconverge.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_defocus.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_defocus.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_distortion.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_distortion.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_ntsc_decode.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_ntsc_decode.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_ntsc_encode.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_ntsc_encode.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_phosphor.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_phosphor.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_post.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_post.sc
View File

0
src/osd/modules/render/bgfx/shaders/fs_prescale.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_prescale.sc
View File

9
src/osd/modules/render/bgfx/shaders/chains/hlsl/varying.def.sc Normal file
View File

@ -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
src/osd/modules/render/bgfx/shaders/vs_blit.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_blit.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_color.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_color.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_deconverge.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_deconverge.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_defocus.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_defocus.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_distortion.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_distortion.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_ntsc_decode.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_ntsc_decode.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_ntsc_encode.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_ntsc_encode.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_phosphor.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_phosphor.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_post.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_post.sc
View File

0
src/osd/modules/render/bgfx/shaders/vs_prescale.sc → src/osd/modules/render/bgfx/shaders/chains/hlsl/vs_prescale.sc
View File

14
src/osd/modules/render/bgfx/shaders/chains/unfiltered/fs_blit.sc Normal file
View File

@ -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;
}

6
src/osd/modules/render/bgfx/shaders/chains/unfiltered/varying.def.sc Normal file
View File

@ -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;

14
src/osd/modules/render/bgfx/shaders/chains/unfiltered/vs_blit.sc Normal file
View File

@ -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;
}

4
src/osd/modules/render/bgfx/shaders/varying.def.sc
View File

@ -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;

4
src/osd/modules/render/bgfx/slider.cpp
View File

@ -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;

28
src/osd/modules/render/bgfx/targetmanager.cpp
View File

@ -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;
}

3
src/osd/modules/render/bgfx/targetmanager.h
View File

@ -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);

23
src/osd/modules/render/bgfx/targetreader.cpp
View File

@ -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)

3
src/osd/modules/render/bgfx/targetreader.h
View File

@ -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);

33
src/osd/modules/render/bgfx/texturemanager.cpp
View File

@ -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;
}
}

1
src/osd/modules/render/bgfx/texturemanager.h
View File

@ -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);

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

@ -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)
{

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

@ -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;
}

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

@ -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
View 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__