diff --git a/bgfx/chains/hlsl.json b/bgfx/chains/hlsl.json index 3f62dd77f5f..e99c7195b76 100644 --- a/bgfx/chains/hlsl.json +++ b/bgfx/chains/hlsl.json @@ -96,10 +96,11 @@ { "type": "float", "name": "scanline_height", "text": "Individual Scanline Scale", "default": 1.00, "max": 4.00, "min": 0.0, "step": 0.01, "format": "%1.2f", "screen": "crt" }, { "type": "float", "name": "scanline_variation", "text": "Scanline Variation", "default": 1.00, "max": 4.00, "min": 0.0, "step": 0.01, "format": "%1.2f", "screen": "crt" }, - { "type": "float", "name": "shadow_alpha", "text": "Shadow Mask Amount", "default": 0.20, "max": 1.00, "min": 0.00, "step": 0.01, "format": "%1.2f", "screen": "crt" }, - { "type": "vec2", "name": "shadow_uv_count", "text": "Shadow Mask Pixel Count ", "default": [ 12, 12 ], "max": [ 128, 128 ], "min": [ 1, 1 ], "step": 1, "format": "%3f", "screen": "crt" }, - { "type": "vec2", "name": "shadow_uv_size", "text": "Shadow Mask UV Size ", "default": [ 0.500, 0.500 ], "max": [ 1.000, 1.000 ], "min": [ 0.000, 0.000 ], "step": 0.001, "format": "%1.3f", "screen": "crt" }, - { "type": "vec2", "name": "shadow_uv_offset", "text": "Shadow Mask UV Offset ", "default": [ 0.000, 0.000 ], "max": [ 1.000, 1.000 ], "min": [ 0.000, 0.000 ], "step": 0.001, "format": "%1.3f", "screen": "crt" }, + { "type": "intenum", "name": "shadow_tile_mode", "text": "Shadow Mask Tile Mode", "default": 0, "max": 1, "min": 0, "step": 1, "format": "%s", "screen": "any", "strings": [ "Screen", "Source" ] }, + { "type": "float", "name": "shadow_alpha", "text": "Shadow Mask Amount", "default": 0.20, "max": 1.00, "min": 0.00, "step": 0.01, "format": "%1.2f", "screen": "crt" }, + { "type": "vec2", "name": "shadow_uv_count", "text": "Shadow Mask Pixel Count ", "default": [ 12, 12 ], "max": [ 128, 128 ], "min": [ 1, 1 ], "step": 1, "format": "%3f", "screen": "crt" }, + { "type": "vec2", "name": "shadow_uv_size", "text": "Shadow Mask UV Size ", "default": [ 0.500, 0.500 ], "max": [ 1.000, 1.000 ], "min": [ 0.000, 0.000 ], "step": 0.001, "format": "%1.3f", "screen": "crt" }, + { "type": "vec2", "name": "shadow_uv_offset", "text": "Shadow Mask UV Offset ", "default": [ 0.000, 0.000 ], "max": [ 1.000, 1.000 ], "min": [ 0.000, 0.000 ], "step": 0.001, "format": "%1.3f", "screen": "crt" }, { "type": "float", "name": "humbar_alpha", "text": "Hum Bar Amount", "default": 0.05, "max": 1.00, "min": 0.00, "step": 0.01, "format": "%1.2f", "screen": "crt" }, { "type": "float", "name": "humbar_hertz_rate", "text": "Hum Bar Frequency", "default": 0.001, "max": 1.000, "min": 0.000, "step": 0.00001, "format": "%1.5f", "screen": "crt" }, @@ -280,6 +281,9 @@ // bilinear (optional, texture and target only): Whether to apply bilinear filtering to the sampler. // values: true, false // default: true + // + // selection (optional, option and texture only): Determines the name of the selection and alowes to select other textures in the same directory as the specified texture file. + // values: Any valid ASCII string. { "sampler": "s_tex", "texture": "screen" } ], @@ -451,6 +455,7 @@ { "uniform": "u_scanline_bright_offset", "slider": "scanline_bright_offset" }, { "uniform": "u_scanline_height", "slider": "scanline_height" }, { "uniform": "u_scanline_variation", "slider": "scanline_variation" }, + { "uniform": "u_shadow_tile_mode", "slider": "shadow_tile_mode" }, { "uniform": "u_shadow_alpha", "slider": "shadow_alpha" }, { "uniform": "u_shadow_count", "slider": "shadow_uv_count" }, { "uniform": "u_shadow_uv", "slider": "shadow_uv_size" }, @@ -465,7 +470,7 @@ ], "input": [ { "sampler": "s_tex", "target": "internal" }, - { "sampler": "s_shadow", "option": "bgfx_shadow_mask" } + { "sampler": "s_shadow", "option": "bgfx_shadow_mask", "selection": "Shadow Mask" } ], "output": "internal" }, diff --git a/bgfx/effects/hlsl/post.json b/bgfx/effects/hlsl/post.json index a30e921e4c2..1fb934a36c7 100644 --- a/bgfx/effects/hlsl/post.json +++ b/bgfx/effects/hlsl/post.json @@ -35,6 +35,7 @@ { "name": "u_time", "type": "vec4", "values": [ 0.0, 0.0, 0.0, 0.0 ] }, { "name": "u_screen_scale", "type": "vec4", "values": [ 1.0, 1.0, 0.0, 0.0 ] }, { "name": "u_screen_offset", "type": "vec4", "values": [ 0.0, 0.0, 0.0, 0.0 ] }, + { "name": "u_shadow_tile_mode", "type": "vec4", "values": [ 0.0, 0.0, 0.0, 0.0 ] }, { "name": "u_scanline_alpha", "type": "vec4", "values": [ 0.0, 0.0, 0.0, 0.0 ] }, { "name": "u_scanline_scale", "type": "vec4", "values": [ 1.0, 0.0, 0.0, 0.0 ] }, { "name": "u_scanline_bright_scale", "type": "vec4", "values": [ 1.0, 0.0, 0.0, 0.0 ] }, diff --git a/bgfx/shaders/dx11/chains/hlsl/fs_post.bin b/bgfx/shaders/dx11/chains/hlsl/fs_post.bin index 4081afffd7a..740cea66bf5 100644 Binary files a/bgfx/shaders/dx11/chains/hlsl/fs_post.bin and b/bgfx/shaders/dx11/chains/hlsl/fs_post.bin differ diff --git a/bgfx/shaders/dx9/chains/hlsl/fs_post.bin b/bgfx/shaders/dx9/chains/hlsl/fs_post.bin index efd4837d48a..cc98415c59f 100644 Binary files a/bgfx/shaders/dx9/chains/hlsl/fs_post.bin and b/bgfx/shaders/dx9/chains/hlsl/fs_post.bin differ diff --git a/bgfx/shaders/gles/chains/hlsl/fs_post.bin b/bgfx/shaders/gles/chains/hlsl/fs_post.bin index f892bd39fc2..3969bd47936 100644 Binary files a/bgfx/shaders/gles/chains/hlsl/fs_post.bin and b/bgfx/shaders/gles/chains/hlsl/fs_post.bin differ diff --git a/bgfx/shaders/glsl/chains/hlsl/fs_post.bin b/bgfx/shaders/glsl/chains/hlsl/fs_post.bin index 76201d8f610..60cc2675a22 100644 Binary files a/bgfx/shaders/glsl/chains/hlsl/fs_post.bin and b/bgfx/shaders/glsl/chains/hlsl/fs_post.bin differ diff --git a/bgfx/shaders/metal/chains/hlsl/fs_post.bin b/bgfx/shaders/metal/chains/hlsl/fs_post.bin index 25f3187fbe4..2be5d0aaa6e 100644 Binary files a/bgfx/shaders/metal/chains/hlsl/fs_post.bin and b/bgfx/shaders/metal/chains/hlsl/fs_post.bin differ diff --git a/hlsl/post.fx b/hlsl/post.fx index 81233f76b4e..dc7c4bd8322 100644 --- a/hlsl/post.fx +++ b/hlsl/post.fx @@ -158,7 +158,6 @@ float2 GetAdjustedCoords(float2 coord) return coord; } -// vector screen has the same quad texture coordinates for every screen orientation, raster screen differs float2 GetShadowCoord(float2 QuadCoord, float2 SourceCoord) { float2 QuadTexel = 1.0f / QuadDims; diff --git a/src/osd/modules/render/bgfx/chain.h b/src/osd/modules/render/bgfx/chain.h index 465e44fea85..4e7a0587cd9 100644 --- a/src/osd/modules/render/bgfx/chain.h +++ b/src/osd/modules/render/bgfx/chain.h @@ -35,6 +35,7 @@ public: // Getters std::vector& sliders() { return m_sliders; } + std::vector& entries() { return m_entries; } uint32_t applicable_passes(); bool transform() { return m_transform; } diff --git a/src/osd/modules/render/bgfx/chainentry.cpp b/src/osd/modules/render/bgfx/chainentry.cpp index fc97e909260..ec802e83699 100644 --- a/src/osd/modules/render/bgfx/chainentry.cpp +++ b/src/osd/modules/render/bgfx/chainentry.cpp @@ -28,7 +28,7 @@ #include "render.h" -bgfx_chain_entry::bgfx_chain_entry(std::string name, bgfx_effect* effect, clear_state* clear, std::vector suppressors, std::vector inputs, std::vector uniforms, target_manager& targets, std::string output) +bgfx_chain_entry::bgfx_chain_entry(std::string name, bgfx_effect* effect, clear_state* clear, std::vector suppressors, std::vector inputs, std::vector uniforms, target_manager& targets, std::string output) : m_name(name) , m_effect(effect) , m_clear(clear) @@ -42,6 +42,11 @@ bgfx_chain_entry::bgfx_chain_entry(std::string name, bgfx_effect* effect, clear_ bgfx_chain_entry::~bgfx_chain_entry() { + for (bgfx_input_pair* input : m_inputs) + { + delete input; + } + m_inputs.clear(); for (bgfx_entry_uniform* uniform : m_uniforms) { delete uniform; @@ -59,9 +64,9 @@ void bgfx_chain_entry::submit(int view, render_primitive* prim, texture_manager& return; } - for (bgfx_input_pair input : m_inputs) + for (bgfx_input_pair* input : m_inputs) { - input.bind(m_effect, m_targets, textures, screen); + input->bind(m_effect, screen); } bgfx::TransientVertexBuffer buffer; @@ -92,7 +97,7 @@ void bgfx_chain_entry::setup_screensize_uniforms(texture_manager& textures, uint float height = screen_height; if (m_inputs.size() > 0) { - std::string name = m_inputs[0].texture() + std::to_string(screen); + std::string name = m_inputs[0]->texture() + std::to_string(screen); width = float(textures.provider(name)->width()); height = float(textures.provider(name)->height()); } @@ -181,7 +186,7 @@ void bgfx_chain_entry::setup_quaddims_uniform(render_primitive* prim) const bgfx_uniform* quad_dims_uniform = m_effect->uniform("u_quad_dims"); if (quad_dims_uniform != nullptr) { - float values[2] = { (prim->bounds.x1 - prim->bounds.x0) + 0.5f, (prim->bounds.y1 - prim->bounds.y0) + 0.5f}; + float values[2] = { float(floor((prim->bounds.x1 - prim->bounds.x0) + 0.5f)), float(floor((prim->bounds.y1 - prim->bounds.y0) + 0.5f)) }; quad_dims_uniform->set(values, sizeof(float) * 2); } } diff --git a/src/osd/modules/render/bgfx/chainentry.h b/src/osd/modules/render/bgfx/chainentry.h index d6452861de2..271941537a7 100644 --- a/src/osd/modules/render/bgfx/chainentry.h +++ b/src/osd/modules/render/bgfx/chainentry.h @@ -34,13 +34,14 @@ class target_manager; class bgfx_chain_entry { public: - bgfx_chain_entry(std::string name, bgfx_effect* effect, clear_state* clear, std::vector suppressors, std::vector inputs, std::vector uniforms, target_manager& targets, std::string output); + bgfx_chain_entry(std::string name, bgfx_effect* effect, clear_state* clear, std::vector suppressors, std::vector inputs, std::vector uniforms, target_manager& targets, std::string output); ~bgfx_chain_entry(); void submit(int view, render_primitive* prim, texture_manager& textures, uint16_t screen_width, uint16_t screen_height, float screen_scale_x, float screen_scale_y, float screen_offset_x, float screen_offset_y, uint32_t rotation_type, bool swap_xy, uint64_t blend, int32_t screen); // Getters std::string name() const { return m_name; } + std::vector& inputs() { return m_inputs; } bool skip(); private: @@ -62,7 +63,7 @@ private: bgfx_effect* m_effect; clear_state* m_clear; std::vector m_suppressors; - std::vector m_inputs; + std::vector m_inputs; std::vector m_uniforms; target_manager& m_targets; std::string m_output; diff --git a/src/osd/modules/render/bgfx/chainentryreader.cpp b/src/osd/modules/render/bgfx/chainentryreader.cpp index c3f214f1d3e..39edd9f685c 100644 --- a/src/osd/modules/render/bgfx/chainentryreader.cpp +++ b/src/osd/modules/render/bgfx/chainentryreader.cpp @@ -20,6 +20,7 @@ #include "targetmanager.h" #include "effectmanager.h" #include "chainentry.h" +#include "chainmanager.h" #include "slider.h" #include "inputpair.h" #include "entryuniform.h" @@ -29,7 +30,7 @@ #include "clear.h" #include "clearreader.h" -bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::string prefix, osd_options& options, texture_manager& textures, target_manager& targets, effect_manager& effects, std::map& sliders, std::map& params, uint32_t screen_index) +bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::string prefix, chain_manager& chains, std::map& sliders, std::map& params, uint32_t screen_index) { if (!validate_parameters(value, prefix)) { @@ -37,7 +38,7 @@ bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::s return nullptr; } - bgfx_effect* effect = effects.effect(value["effect"].GetString()); + bgfx_effect* effect = chains.effects().effect(value["effect"].GetString()); if (effect == nullptr) { return nullptr; @@ -45,7 +46,7 @@ bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::s std::string name = value["name"].GetString(); - std::vector inputs; + std::vector inputs; if (value.HasMember("input")) { const Value& input_array = value["input"]; @@ -62,19 +63,105 @@ bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::s if (!READER_CHECK(!has_target || input["target"].IsString(), (prefix + "input[" + std::to_string(i) + ": Value 'target' must be a string\n").c_str())) return nullptr; if (!READER_CHECK(!has_option || input["option"].IsString(), (prefix + "input[" + std::to_string(i) + ": Value 'option' must be a string\n").c_str())) return nullptr; if (!READER_CHECK(has_target || !input.HasMember("bilinear") || input["bilinear"].IsBool(), (prefix + "input[" + std::to_string(i) + ": Value 'bilinear' must be a boolean\n").c_str())) return nullptr; + if (!READER_CHECK(has_texture || has_option || !input.HasMember("selection") || input["selection"].IsString(), (prefix + "input[" + std::to_string(i) + ": Value 'selection' must be a string\n").c_str())) return nullptr; + bool bilinear = get_bool(input, "bilinear", true); + std::string selection = get_string(input, "selection", ""); + std::vector texture_names; std::string texture_name = ""; - if (has_texture) + if (has_texture || has_option) { - texture_name = input["texture"].GetString(); - if (texture_name != "screen") + if (has_texture) { - bool bilinear = get_bool(input, "bilinear", true); - uint32_t flags = bilinear ? 0 : (BGFX_TEXTURE_MIN_POINT | BGFX_TEXTURE_MAG_POINT | BGFX_TEXTURE_MIP_POINT); - bgfx_texture* texture = textures.create_png_texture(options.art_path(), texture_name, texture_name, flags, screen_index); - if (texture == nullptr) + texture_name = input["texture"].GetString(); + } + if (has_option) + { + std::string option = input["option"].GetString(); + + texture_name = chains.options().value(option.c_str()); + } + + if (texture_name != "" && texture_name != "screen") + { + if (selection == "") { - return nullptr; + // create texture for specified file name + uint32_t flags = bilinear ? 0 : (BGFX_TEXTURE_MIN_POINT | BGFX_TEXTURE_MAG_POINT | BGFX_TEXTURE_MIP_POINT); + bgfx_texture* texture = chains.textures().create_png_texture(chains.options().art_path(), texture_name, texture_name, flags, screen_index); + if (texture == nullptr) + { + return nullptr; + } + } + else + { + // create texture for specified file name + uint32_t flags = bilinear ? 0 : (BGFX_TEXTURE_MIN_POINT | BGFX_TEXTURE_MAG_POINT | BGFX_TEXTURE_MIP_POINT); + bgfx_texture* texture = chains.textures().create_png_texture(chains.options().art_path(), texture_name, texture_name, flags, screen_index); + if (texture == nullptr) + { + return nullptr; + } + + // get directory of file + std::string directory_path = std::string(chains.options().art_path()); + std::string file_directory = ""; + const size_t last_slash = texture_name.rfind('/'); + if (last_slash != std::string::npos) + { + file_directory = texture_name.substr(0, last_slash); + + directory_path += "/" + file_directory; + } + + osd_directory *directory = osd_opendir(directory_path.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 file(entry->name); + std::string extension(".png"); + + // split into file name and extension + std::string file_name; + std::string file_extension; + const size_t last_dot = file.rfind('.'); + if (last_dot != std::string::npos) + { + file_name = file.substr(0, last_dot); + file_extension = file.substr(last_dot, file.length() - last_dot); + } + + std::string file_path; + if (file_directory == "") + { + file_path = file; + } + else + { + file_path = file_directory + "/" + file; + } + + // check for .png extension + if (file_extension == extension) + { + // create textures for all files containd in the path of the specified file name + uint32_t flags = bilinear ? 0 : (BGFX_TEXTURE_MIN_POINT | BGFX_TEXTURE_MAG_POINT | BGFX_TEXTURE_MIP_POINT); + bgfx_texture* texture = chains.textures().create_png_texture(chains.options().art_path(), file_path, file_path, flags, screen_index); + if (texture == nullptr) + { + return nullptr; + } + texture_names.push_back(file_path); + } + } + } + + osd_closedir(directory); + } } } } @@ -82,24 +169,14 @@ bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::s { texture_name = input["target"].GetString(); } - else if (has_option) - { - bool bilinear = get_bool(input, "bilinear", true); - uint32_t flags = bilinear ? 0 : (BGFX_TEXTURE_MIN_POINT | BGFX_TEXTURE_MAG_POINT | BGFX_TEXTURE_MIP_POINT); - texture_name = input["option"].GetString(); - bgfx_texture* texture = textures.create_png_texture(options.art_path(), options.value(texture_name.c_str()), texture_name, flags, screen_index); - if (texture == nullptr) - { - return nullptr; - } - } else { return nullptr; } std::string sampler = input["sampler"].GetString(); - inputs.push_back(bgfx_input_pair(i, sampler, texture_name)); + bgfx_input_pair* input_pair = new bgfx_input_pair(i, sampler, texture_name, texture_names, selection, chains, screen_index); + inputs.push_back(input_pair); } } @@ -148,7 +225,7 @@ bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::s } std::string output = value["output"].GetString(); - return new bgfx_chain_entry(name, effect, clear, suppressors, inputs, uniforms, targets, output); + return new bgfx_chain_entry(name, effect, clear, suppressors, inputs, uniforms, chains.targets(), output); } bool chain_entry_reader::validate_parameters(const Value& value, std::string prefix) diff --git a/src/osd/modules/render/bgfx/chainentryreader.h b/src/osd/modules/render/bgfx/chainentryreader.h index 267fe63948e..0f604e9a71f 100644 --- a/src/osd/modules/render/bgfx/chainentryreader.h +++ b/src/osd/modules/render/bgfx/chainentryreader.h @@ -15,18 +15,15 @@ #include "statereader.h" -class osd_options; class bgfx_chain_entry; -class texture_manager; -class target_manager; -class effect_manager; class bgfx_slider; class bgfx_parameter; +class chain_manager; class chain_entry_reader : public state_reader { public: - static bgfx_chain_entry* read_from_value(const Value& value, std::string prefix, osd_options& options, texture_manager& textures, target_manager& targets, effect_manager& effects, std::map& sliders, std::map& params, uint32_t screen_index); + static bgfx_chain_entry* read_from_value(const Value& value, std::string prefix, chain_manager& chains, std::map& sliders, std::map& params, uint32_t screen_index); private: static bool validate_parameters(const Value& value, std::string prefix); diff --git a/src/osd/modules/render/bgfx/chainmanager.cpp b/src/osd/modules/render/bgfx/chainmanager.cpp index 1d5c162c61f..c3aeb586136 100644 --- a/src/osd/modules/render/bgfx/chainmanager.cpp +++ b/src/osd/modules/render/bgfx/chainmanager.cpp @@ -162,7 +162,7 @@ bgfx_chain* chain_manager::load_chain(std::string name, uint32_t screen_index) return nullptr; } - 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); + bgfx_chain* chain = chain_reader::read_from_value(document, name + ": ", *this, screen_index); if (chain == nullptr) { @@ -472,6 +472,20 @@ std::vector chain_manager::get_slider_list() continue; } + std::vector chain_entries = chain->entries(); + for (bgfx_chain_entry* entry : chain_entries) + { + std::vector entry_inputs = entry->inputs(); + for (bgfx_input_pair* input : entry_inputs) + { + std::vector input_sliders = input->get_slider_list(); + for (ui_menu_item slider : input_sliders) + { + sliders.push_back(slider); + } + } + } + std::vector chain_sliders = chain->sliders(); for (bgfx_slider* slider : chain_sliders) { diff --git a/src/osd/modules/render/bgfx/chainmanager.h b/src/osd/modules/render/bgfx/chainmanager.h index 022dbecfa14..d527bc7122c 100644 --- a/src/osd/modules/render/bgfx/chainmanager.h +++ b/src/osd/modules/render/bgfx/chainmanager.h @@ -25,6 +25,7 @@ class running_machine; class osd_window; class slider_dirty_notifier; +class render_primitive; class bgfx_chain; class bgfx_slider; @@ -39,6 +40,14 @@ public: int32_t chain_changed(int32_t index, std::string *str, int32_t newval); // Getters + running_machine& machine() { return m_machine; } + osd_options& options() { return m_options; } + texture_manager& textures() { return m_textures; } + target_manager& targets() { return m_targets; } + effect_manager& effects() { return m_effects; } + slider_dirty_notifier& slider_notifier() { return m_slider_notifier; } + uint32_t window_index() { return m_window_index; } + uint32_t screen_count() { return m_screen_count; } bgfx_chain* screen_chain(uint32_t screen); bgfx_chain* load_chain(std::string name, uint32_t screen_index); bool has_applicable_chain(uint32_t screen); diff --git a/src/osd/modules/render/bgfx/chainreader.cpp b/src/osd/modules/render/bgfx/chainreader.cpp index 9e79eb1f19d..e92be498547 100644 --- a/src/osd/modules/render/bgfx/chainreader.cpp +++ b/src/osd/modules/render/bgfx/chainreader.cpp @@ -14,8 +14,8 @@ #include #include "chainreader.h" - #include "chain.h" +#include "chainmanager.h" #include "sliderreader.h" #include "paramreader.h" #include "chainentryreader.h" @@ -24,7 +24,7 @@ #include "slider.h" #include "parameter.h" -bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix, osd_options& options, running_machine& machine, uint32_t window_index, uint32_t screen_index, texture_manager& textures, target_manager& targets, effect_manager& effects) +bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix, chain_manager& chains, uint32_t screen_index) { if (!validate_parameters(value, prefix)) { @@ -41,7 +41,7 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix const Value& slider_array = value["sliders"]; for (UINT32 i = 0; i < slider_array.Size(); i++) { - std::vector expanded_sliders = slider_reader::read_from_value(slider_array[i], prefix + "sliders[" + std::to_string(i) + "]: ", machine, window_index, screen_index); + std::vector expanded_sliders = slider_reader::read_from_value(slider_array[i], prefix + "sliders[" + std::to_string(i) + "]: ", chains, screen_index); if (expanded_sliders.size() == 0) { return nullptr; @@ -74,7 +74,7 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix const Value& param_array = value["parameters"]; for (UINT32 i = 0; i < param_array.Size(); i++) { - bgfx_parameter* parameter = parameter_reader::read_from_value(param_array[i], prefix + "parameters[" + std::to_string(i) + "]; ", window_index); + bgfx_parameter* parameter = parameter_reader::read_from_value(param_array[i], prefix + "parameters[" + std::to_string(i) + "]; ", chains); if (parameter == nullptr) { return nullptr; @@ -98,7 +98,7 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix // TODO: Move into its own reader for (UINT32 i = 0; i < target_array.Size(); i++) { - bgfx_target* target = 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) + "]: ", chains, screen_index); if (target == nullptr) { return nullptr; @@ -114,7 +114,7 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix const Value& entry_array = value["passes"]; for (UINT32 i = 0; i < entry_array.Size(); i++) { - bgfx_chain_entry* entry = chain_entry_reader::read_from_value(entry_array[i], prefix + "passes[" + std::to_string(i) + "]: ", options, textures, targets, effects, slider_map, param_map, screen_index); + bgfx_chain_entry* entry = chain_entry_reader::read_from_value(entry_array[i], prefix + "passes[" + std::to_string(i) + "]: ", chains, slider_map, param_map, screen_index); if (entry == nullptr) { return nullptr; @@ -123,7 +123,7 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix } } - return new bgfx_chain(name, author, transform, targets, sliders, parameters, entries, target_list, screen_index); + return new bgfx_chain(name, author, transform, chains.targets(), sliders, parameters, entries, target_list, screen_index); } bool chain_reader::validate_parameters(const Value& value, std::string prefix) diff --git a/src/osd/modules/render/bgfx/chainreader.h b/src/osd/modules/render/bgfx/chainreader.h index 80d298c7e4c..a2fa3ba28a5 100644 --- a/src/osd/modules/render/bgfx/chainreader.h +++ b/src/osd/modules/render/bgfx/chainreader.h @@ -14,14 +14,12 @@ #include "statereader.h" class bgfx_chain; -class texture_manager; -class target_manager; -class effect_manager; +class chain_manager; class chain_reader : public state_reader { public: - static bgfx_chain* read_from_value(const Value& value, std::string prefix, osd_options& options, running_machine& machine, uint32_t window_index, uint32_t screen_index, texture_manager& textures, target_manager& targets, effect_manager& effects); + static bgfx_chain* read_from_value(const Value& value, std::string prefix, chain_manager& chains, uint32_t screen_index); private: static bool validate_parameters(const Value& value, std::string prefix); diff --git a/src/osd/modules/render/bgfx/inputpair.cpp b/src/osd/modules/render/bgfx/inputpair.cpp index d8777257187..4de54404a6b 100644 --- a/src/osd/modules/render/bgfx/inputpair.cpp +++ b/src/osd/modules/render/bgfx/inputpair.cpp @@ -9,29 +9,42 @@ // //============================================================ +#include "ui/uimain.h" + #include "emucore.h" #include "inputpair.h" #include "texture.h" #include "target.h" #include "effect.h" +#include "render.h" #include "uniform.h" -#include "texturemanager.h" -#include "targetmanager.h" +#include "chainmanager.h" +#include "slider.h" +#include "sliderdirtynotifier.h" -bgfx_input_pair::bgfx_input_pair(int index, std::string sampler, std::string texture) +bgfx_input_pair::bgfx_input_pair(int index, std::string sampler, std::string texture, std::vector available_textures, std::string selection, chain_manager& chains, uint32_t screen_index) : m_index(index) , m_sampler(sampler) , m_texture(texture) + , m_available_textures(available_textures) + , m_selection(selection) + , m_chains(chains) { + if (m_available_textures.size() > 0) + { + m_current_texture = std::find(m_available_textures.begin(), m_available_textures.end(), m_texture) - m_available_textures.begin(); + + create_selection_slider(screen_index); + } } -void bgfx_input_pair::bind(bgfx_effect *effect, target_manager& targets, texture_manager& textures, const int32_t screen) const +void bgfx_input_pair::bind(bgfx_effect *effect, const int32_t screen) const { assert(effect->uniform(m_sampler) != nullptr); std::string name = m_texture + std::to_string(screen); - bgfx_texture_handle_provider* provider = textures.provider(name); + bgfx_texture_handle_provider* provider = chains().textures().provider(name); bgfx_uniform *tex_size = effect->uniform("u_tex_size" + std::to_string(m_index)); if (tex_size != nullptr) { @@ -39,5 +52,89 @@ void bgfx_input_pair::bind(bgfx_effect *effect, target_manager& targets, texture tex_size->set(values, sizeof(float) * 2); } - bgfx::setTexture(m_index, effect->uniform(m_sampler)->handle(), textures.handle(name)); + bgfx::setTexture(m_index, effect->uniform(m_sampler)->handle(), chains().textures().handle(name)); +} + +static INT32 update_trampoline(running_machine &machine, void *arg, int id, std::string *str, INT32 newval) +{ + if (arg != nullptr) + { + return reinterpret_cast(arg)->texture_changed(id, str, newval); + } + return 0; +} + +int32_t bgfx_input_pair::texture_changed(int32_t id, std::string *str, int32_t newval) +{ + if (newval != SLIDER_NOCHANGE) + { + m_current_texture = newval; + m_texture = m_available_textures[m_current_texture]; + + chains().slider_notifier().set_sliders_dirty(); + } + + if (str != nullptr) + { + std::string file = m_texture; + const size_t last_slash = m_texture.rfind('/'); + if (last_slash != std::string::npos) + { + file = m_texture.substr(last_slash + 1, m_texture.length() - (last_slash + 1)); + } + + std::string file_name; + const size_t last_dot = file.rfind('.'); + if (last_dot != std::string::npos) + { + file_name = file.substr(0, last_dot); + } + + *str = string_format("%s", file_name.c_str()); + } + + return m_current_texture; +} + +void bgfx_input_pair::create_selection_slider(uint32_t screen_index) +{ + std::string description = "Window " + std::to_string(chains().window_index()) + ", Screen " + std::to_string(screen_index) + " " + m_selection + ":"; + size_t size = sizeof(slider_state) + description.length(); + slider_state *state = reinterpret_cast(auto_alloc_array_clear(chains().machine(), UINT8, size)); + + state->minval = 0; + state->defval = m_current_texture; + state->maxval = m_available_textures.size() - 1; + state->incval = 1; + state->update = update_trampoline; + state->arg = this; + state->id = screen_index; + strcpy(state->description, description.c_str()); + + ui_menu_item item; + item.text = state->description; + item.subtext = ""; + item.flags = 0; + item.ref = state; + item.type = ui_menu_item_type::SLIDER; + m_selection_slider = item; +} + +bool bgfx_input_pair::needs_sliders() +{ + return chains().screen_count() > 0 && m_available_textures.size() > 1; +} + +std::vector bgfx_input_pair::get_slider_list() +{ + std::vector sliders; + + if (!needs_sliders()) + { + return sliders; + } + + sliders.push_back(m_selection_slider); + + return sliders; } diff --git a/src/osd/modules/render/bgfx/inputpair.h b/src/osd/modules/render/bgfx/inputpair.h index ae8e37981cc..550595a1c55 100644 --- a/src/osd/modules/render/bgfx/inputpair.h +++ b/src/osd/modules/render/bgfx/inputpair.h @@ -16,25 +16,37 @@ #include +#include "ui/uimain.h" + class bgfx_effect; -class texture_manager; -class target_manager; +class chain_manager; class bgfx_input_pair { public: - bgfx_input_pair(int index, std::string sampler, std::string texture); + bgfx_input_pair(int index, std::string sampler, std::string texture, std::vector available_textures, std::string selection, chain_manager& chains, uint32_t screen_index); - void bind(bgfx_effect *effect, target_manager& targets, texture_manager& textures, const int32_t screen) const; + void bind(bgfx_effect *effect, const int32_t screen) const; + int32_t texture_changed(int32_t index, std::string *str, int32_t newval); // Getters + chain_manager& chains() const { return m_chains; } std::string sampler() const { return m_sampler; } std::string texture() const { return m_texture; } + std::vector get_slider_list(); private: - int m_index; - std::string m_sampler; - std::string m_texture; + void create_selection_slider(uint32_t screen_index); + bool needs_sliders(); + + int m_index; + std::string m_sampler; + std::string m_texture; + std::vector m_available_textures; + std::string m_selection; + chain_manager& m_chains; + int32_t m_current_texture; + ui_menu_item m_selection_slider; }; #endif // __DRAWBGFX_INPUT_PAIR__ diff --git a/src/osd/modules/render/bgfx/paramreader.cpp b/src/osd/modules/render/bgfx/paramreader.cpp index 20ea024c4e6..f24bb6a475b 100644 --- a/src/osd/modules/render/bgfx/paramreader.cpp +++ b/src/osd/modules/render/bgfx/paramreader.cpp @@ -14,6 +14,7 @@ #include "frameparameter.h" #include "windowparameter.h" #include "timeparameter.h" +#include "chainmanager.h" const parameter_reader::string_to_enum parameter_reader::TYPE_NAMES[parameter_reader::TYPE_COUNT] = { { "frame", bgfx_parameter::parameter_type::PARAM_FRAME }, @@ -21,7 +22,7 @@ const parameter_reader::string_to_enum parameter_reader::TYPE_NAMES[parameter_re { "time", bgfx_parameter::parameter_type::PARAM_TIME } }; -bgfx_parameter* parameter_reader::read_from_value(const Value& value, std::string prefix, uint32_t window_index) +bgfx_parameter* parameter_reader::read_from_value(const Value& value, std::string prefix, chain_manager& chains) { if (!validate_parameters(value, prefix)) { @@ -38,7 +39,7 @@ bgfx_parameter* parameter_reader::read_from_value(const Value& value, std::strin } else if (type == bgfx_parameter::parameter_type::PARAM_WINDOW) { - return new bgfx_window_parameter(name, type, window_index); + return new bgfx_window_parameter(name, type, chains.window_index()); } else if (type == bgfx_parameter::parameter_type::PARAM_TIME) { diff --git a/src/osd/modules/render/bgfx/paramreader.h b/src/osd/modules/render/bgfx/paramreader.h index 74d55d31b0d..013d6589cc3 100644 --- a/src/osd/modules/render/bgfx/paramreader.h +++ b/src/osd/modules/render/bgfx/paramreader.h @@ -14,11 +14,12 @@ #include "statereader.h" class bgfx_parameter; +class chain_manager; class parameter_reader : public state_reader { public: - static bgfx_parameter* read_from_value(const Value& value, std::string prefix, uint32_t window_index); + static bgfx_parameter* read_from_value(const Value& value, std::string prefix, chain_manager& chains); private: static bool validate_parameters(const Value& value, std::string prefix); diff --git a/src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_post.sc b/src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_post.sc index 6434c3dae2f..ee2fd0fd148 100644 --- a/src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_post.sc +++ b/src/osd/modules/render/bgfx/shaders/chains/hlsl/fs_post.sc @@ -14,6 +14,7 @@ uniform vec4 u_source_dims; // size of the guest machine uniform vec4 u_quad_dims; uniform vec4 u_screen_scale; uniform vec4 u_screen_offset; +// uniform vec4 u_back_color; // TODO // User-supplied uniform vec4 u_scanline_alpha; @@ -23,6 +24,7 @@ uniform vec4 u_scanline_bright_offset; uniform vec4 u_scanline_jitter; uniform vec4 u_scanline_height; uniform vec4 u_scanline_variation; +uniform vec4 u_shadow_tile_mode; uniform vec4 u_shadow_alpha; uniform vec4 u_shadow_count; uniform vec4 u_shadow_uv; @@ -61,32 +63,34 @@ vec2 GetAdjustedCoords(vec2 coord) return coord; } -// vector screen has the same quad texture coordinates for every screen orientation, raster screen differs vec2 GetShadowCoord(vec2 QuadCoord, vec2 SourceCoord) { - vec2 QuadTexel = vec2(1.0, 1.0) / (u_quad_dims.xy - 0.5f); - - vec2 canvasCoord = QuadCoord + u_shadow_uv_offset.xy / u_quad_dims.xy; + vec2 canvasCoord = u_shadow_tile_mode.x == 0.0 + ? QuadCoord + u_shadow_uv_offset.xy / u_quad_dims.xy + : SourceCoord + u_shadow_uv_offset.xy / u_source_dims.xy; + vec2 canvasTexelDims = u_shadow_tile_mode.x == 0.0 + ? vec2(1.0, 1.0) / u_quad_dims.xy + : vec2(1.0, 1.0) / u_source_dims.xy; vec2 shadowUV = u_shadow_uv.xy; vec2 shadowCount = u_shadow_count.xy; // swap x/y in screen mode (not source mode) - canvasCoord = u_swap_xy.x > 0.0 + canvasCoord = u_shadow_tile_mode.x == 0.0 && u_swap_xy.x > 0.0 ? canvasCoord.yx : canvasCoord.xy; // swap x/y in screen mode (not source mode) - shadowCount = u_swap_xy.x > 0.0 + shadowCount = u_shadow_tile_mode.x == 0.0 && u_swap_xy.x > 0.0 ? shadowCount.yx : shadowCount.xy; - vec2 shadowTile = QuadTexel * shadowCount; + vec2 shadowTile = canvasTexelDims * shadowCount; vec2 shadowFrac = fract(canvasCoord / shadowTile); // swap x/y in screen mode (not source mode) - shadowFrac = u_swap_xy.x > 0.0 + shadowFrac = u_shadow_tile_mode.x == 0.0 && u_swap_xy.x > 0.0 ? shadowFrac.yx : shadowFrac.xy; @@ -102,57 +106,66 @@ void main() // Color vec4 BaseColor = texture2D(s_tex, BaseCoord); + // Clamp if (BaseCoord.x < 0.0 || BaseCoord.y < 0.0 || BaseCoord.x > 1.0 || BaseCoord.y > 1.0) { - BaseColor.rgb = vec3(0.0, 0.0, 0.0); + gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); } - - // Mask Simulation - if (u_shadow_alpha.x > 0.0) + else { - vec2 ShadowCoord = GetShadowCoord(v_texcoord0.xy, v_texcoord0.xy); + // Mask Simulation + if (u_shadow_alpha.x > 0.0) + { + vec2 ShadowCoord = GetShadowCoord(v_texcoord0.xy, BaseCoord.xy); - vec4 ShadowColor = texture2D(s_shadow, ShadowCoord); - vec3 ShadowMaskColor = mix(vec3(1.0, 1.0, 1.0), ShadowColor.rgb, u_shadow_alpha.xxx); + vec4 ShadowColor = texture2D(s_shadow, ShadowCoord); + vec3 ShadowMaskColor = mix(vec3(1.0, 1.0, 1.0), ShadowColor.rgb, u_shadow_alpha.xxx); - // apply shadow mask color - BaseColor.rgb *= ShadowMaskColor; + // apply shadow mask color + BaseColor.rgb *= ShadowMaskColor; + + // // TODO + // vec3 ShadowMaskClear = (1.0f - ShadowColor.a) * u_shadow_alpha.xxx; + + // // clear shadow mask by background color + // BaseColor.rgb = mix(BaseColor.rgb, u_back_color.rgb, ShadowMaskClear); + } + + // Color Compression + // increasing the floor of the signal without affecting the ceiling + BaseColor.rgb = u_floor.rgb + (vec3(1.0, 1.0, 1.0) - u_floor.rgb) * BaseColor.rgb; + + // Color Power + BaseColor.r = pow(BaseColor.r, u_power.r); + BaseColor.g = pow(BaseColor.g, u_power.g); + BaseColor.b = pow(BaseColor.b, u_power.b); + + // Scanline Simulation + if (u_scanline_alpha.x > 0.0f) + { + float BrightnessOffset = (u_scanline_bright_offset.x * u_scanline_alpha.x); + float BrightnessScale = (u_scanline_bright_scale.x * u_scanline_alpha.x) + (1.0 - u_scanline_alpha.x); + + float ColorBrightness = 0.299 * BaseColor.r + 0.587 * BaseColor.g + 0.114 * BaseColor.b; + + float ScanCoord = BaseCoord.y * u_source_dims.y * u_scanline_scale.x * 3.1415927; // PI + float ScanCoordJitter = u_scanline_jitter.x * u_jitter_amount.x * 1.618034; // PHI + float ScanSine = sin(ScanCoord + ScanCoordJitter); + float ScanlineWide = u_scanline_height.x + u_scanline_variation.x * max(1.0, u_scanline_height.x) * (1.0 - ColorBrightness); + float ScanSineScaled = pow(ScanSine * ScanSine, ScanlineWide); + float ScanBrightness = ScanSineScaled * BrightnessScale + BrightnessOffset * BrightnessScale; + + BaseColor.rgb *= mix(vec3(1.0, 1.0, 1.0), vec3(ScanBrightness, ScanBrightness, ScanBrightness), u_scanline_alpha.xxx); + } + + // Hum Bar Simulation + if (u_humbar_alpha.x > 0.0f) + { + float HumTimeStep = fract(u_time.x * u_humbar_hertz_rate.x); + float HumBrightness = 1.0 - fract(BaseCoord.y + HumTimeStep) * u_humbar_alpha.x; + BaseColor.rgb *= HumBrightness; + } + + gl_FragColor = vec4(BaseColor.rgb * v_color0.rgb, BaseColor.a); } - - // Color Compression - // increasing the floor of the signal without affecting the ceiling - BaseColor.rgb = u_floor.rgb + (vec3(1.0, 1.0, 1.0) - u_floor.rgb) * BaseColor.rgb; - - // Color Power - BaseColor.r = pow(BaseColor.r, u_power.r); - BaseColor.g = pow(BaseColor.g, u_power.g); - BaseColor.b = pow(BaseColor.b, u_power.b); - - // Scanline Simulation - if (u_scanline_alpha.x > 0.0f) - { - float BrightnessOffset = (u_scanline_bright_offset.x * u_scanline_alpha.x); - float BrightnessScale = (u_scanline_bright_scale.x * u_scanline_alpha.x) + (1.0 - u_scanline_alpha.x); - - float ColorBrightness = 0.299 * BaseColor.r + 0.587 * BaseColor.g + 0.114 * BaseColor.b; - - float ScanCoord = BaseCoord.y * u_source_dims.y * u_scanline_scale.x * 3.1415927; // PI - float ScanCoordJitter = u_scanline_jitter.x * u_jitter_amount.x * 1.618034; // PHI - float ScanSine = sin(ScanCoord + ScanCoordJitter); - float ScanlineWide = u_scanline_height.x + u_scanline_variation.x * max(1.0, u_scanline_height.x) * (1.0 - ColorBrightness); - float ScanSineScaled = pow(ScanSine * ScanSine, ScanlineWide); - float ScanBrightness = ScanSineScaled * BrightnessScale + BrightnessOffset * BrightnessScale; - - BaseColor.rgb *= mix(vec3(1.0, 1.0, 1.0), vec3(ScanBrightness, ScanBrightness, ScanBrightness), u_scanline_alpha.xxx); - } - - // Hum Bar Simulation - if (u_humbar_alpha.x > 0.0f) - { - float HumTimeStep = fract(u_time.x * u_humbar_hertz_rate.x); - float HumBrightness = 1.0 - fract(BaseCoord.y + HumTimeStep) * u_humbar_alpha.x; - BaseColor.rgb *= HumBrightness; - } - - gl_FragColor = vec4(BaseColor.rgb * v_color0.rgb, BaseColor.a); } diff --git a/src/osd/modules/render/bgfx/sliderreader.cpp b/src/osd/modules/render/bgfx/sliderreader.cpp index b2b2f9b7f7a..9a200984c0e 100644 --- a/src/osd/modules/render/bgfx/sliderreader.cpp +++ b/src/osd/modules/render/bgfx/sliderreader.cpp @@ -10,6 +10,7 @@ #include "emu.h" #include "slider.h" +#include "chainmanager.h" const slider_reader::string_to_enum slider_reader::TYPE_NAMES[slider_reader::TYPE_COUNT] = { { "intenum", uint64_t(bgfx_slider::slider_type::SLIDER_INT_ENUM) }, @@ -33,7 +34,7 @@ const slider_reader::string_to_enum slider_reader::SCREEN_NAMES[slider_reader::S { "all", uint64_t(bgfx_slider::screen_type::SLIDER_SCREEN_TYPE_ANY) } }; -std::vector slider_reader::read_from_value(const Value& value, std::string prefix, running_machine& machine, uint32_t window_index, uint32_t screen_index) +std::vector slider_reader::read_from_value(const Value& value, std::string prefix, chain_manager& chains, uint32_t screen_index) { std::vector sliders; @@ -82,7 +83,7 @@ std::vector slider_reader::read_from_value(const Value& value, std break; } - std::string prefixed_desc = "Window " + std::to_string(window_index) + ", Screen " + std::to_string(screen_index) + ", " + description; + std::string prefixed_desc = "Window " + std::to_string(chains.window_index()) + ", Screen " + std::to_string(screen_index) + ", " + description; if (slider_count > 1) { float min[3]; @@ -113,7 +114,7 @@ std::vector slider_reader::read_from_value(const Value& value, std desc = prefixed_desc + "Invalid"; break; } - sliders.push_back(new bgfx_slider(machine, full_name, min[index], defaults[index], max[index], step, type, screen_type, format, desc, strings)); + sliders.push_back(new bgfx_slider(chains.machine(), full_name, min[index], defaults[index], max[index], step, type, screen_type, format, desc, strings)); } } else @@ -121,7 +122,7 @@ std::vector slider_reader::read_from_value(const Value& value, std float min = get_float(value, "min", 0.0f); float def = get_float(value, "default", 0.0f); float max = get_float(value, "max", 1.0f); - sliders.push_back(new bgfx_slider(machine, name + "0", min, def, max, step, type, screen_type, format, prefixed_desc, strings)); + sliders.push_back(new bgfx_slider(chains.machine(), name + "0", min, def, max, step, type, screen_type, format, prefixed_desc, strings)); } return sliders; } @@ -132,7 +133,7 @@ bool slider_reader::get_values(const Value& value, std::string prefix, std::stri const Value& value_array = value[name_str]; for (UINT32 i = 0; i < value_array.Size() && i < count; i++) { - if (!READER_CHECK(value_array[i].IsNumber(), (prefix + "Entry " + std::to_string(i) + " must be a number point\n").c_str())) return false; + if (!READER_CHECK(value_array[i].IsNumber(), (prefix + "Entry " + std::to_string(i) + " must be a number\n").c_str())) return false; values[i] = value_array[i].GetFloat(); } return true; @@ -144,11 +145,11 @@ bool slider_reader::validate_parameters(const Value& value, std::string prefix) if (!READER_CHECK(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str())) return false; if (!READER_CHECK(value.HasMember("min"), (prefix + "Must have a number or array value 'min'\n").c_str())) return false; if (!READER_CHECK(value["min"].IsNumber() || value["min"].IsArray(), (prefix + "Value 'min' must be a number or an array the size of the corresponding slider type\n").c_str())) return false; - if (!READER_CHECK(value.HasMember("default"), (prefix + "Must have a number point or array value 'default'\n").c_str())) return false; - if (!READER_CHECK(value["default"].IsNumber() || value["default"].IsArray(), (prefix + "Value 'default' must be a number point or an array the size of the corresponding slider type\n").c_str())) return false; - if (!READER_CHECK(value.HasMember("max"), (prefix + "Must have a number point or array value 'max'\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("default"), (prefix + "Must have a number or array value 'default'\n").c_str())) return false; + if (!READER_CHECK(value["default"].IsNumber() || value["default"].IsArray(), (prefix + "Value 'default' must be a number or an array the size of the corresponding slider type\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("max"), (prefix + "Must have a number or array value 'max'\n").c_str())) return false; if (!READER_CHECK(value["max"].IsNumber() || value["max"].IsArray(), (prefix + "Value 'max' must be a number or an array the size of the corresponding slider type\n").c_str())) return false; - if (!READER_CHECK(value.HasMember("step"), (prefix + "Must have a number point value 'step'\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("step"), (prefix + "Must have a number value 'step'\n").c_str())) return false; if (!READER_CHECK(value["step"].IsNumber(), (prefix + "Value 'step' must be a number (how much does this slider increment by internally?)\n").c_str())) return false; if (!READER_CHECK(value.HasMember("type"), (prefix + "Must have string value 'type'\n").c_str())) return false; if (!READER_CHECK(value["type"].IsString(), (prefix + "Value 'type' must be a string (what type of slider is this? [int_enum, int, float])\n").c_str())) return false; diff --git a/src/osd/modules/render/bgfx/sliderreader.h b/src/osd/modules/render/bgfx/sliderreader.h index d46d787f287..95c6872e171 100644 --- a/src/osd/modules/render/bgfx/sliderreader.h +++ b/src/osd/modules/render/bgfx/sliderreader.h @@ -16,12 +16,12 @@ #include "statereader.h" class bgfx_slider; -class running_machine; +class chain_manager; class slider_reader : public state_reader { public: - static std::vector read_from_value(const Value& value, std::string prefix, running_machine& machine, uint32_t window_index, uint32_t screen_index); + static std::vector read_from_value(const Value& value, std::string prefix, chain_manager& chains, uint32_t screen_index); private: static bool get_values(const Value& value, std::string prefix, std::string name, float* values, const int count); diff --git a/src/osd/modules/render/bgfx/targetreader.cpp b/src/osd/modules/render/bgfx/targetreader.cpp index c63d05ec015..9a8d6aebb63 100644 --- a/src/osd/modules/render/bgfx/targetreader.cpp +++ b/src/osd/modules/render/bgfx/targetreader.cpp @@ -11,8 +11,8 @@ #include "emu.h" #include +#include "chainmanager.h" #include "targetreader.h" -#include "targetmanager.h" #include "target.h" const target_reader::string_to_enum target_reader::STYLE_NAMES[target_reader::STYLE_COUNT] = { @@ -21,7 +21,7 @@ const target_reader::string_to_enum target_reader::STYLE_NAMES[target_reader::ST { "custom", TARGET_STYLE_CUSTOM } }; -bgfx_target* 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, chain_manager& chains, uint32_t screen_index) { if (!validate_parameters(value, prefix)) { @@ -43,12 +43,12 @@ bgfx_target* target_reader::read_from_value(const Value& value, std::string pref switch (mode) { case TARGET_STYLE_GUEST: - width = targets.width(TARGET_STYLE_GUEST, screen_index); - height = targets.height(TARGET_STYLE_GUEST, screen_index); + width = chains.targets().width(TARGET_STYLE_GUEST, screen_index); + height = chains.targets().height(TARGET_STYLE_GUEST, screen_index); break; case TARGET_STYLE_NATIVE: - width = targets.width(TARGET_STYLE_NATIVE, screen_index); - height = targets.height(TARGET_STYLE_NATIVE, screen_index); + width = chains.targets().width(TARGET_STYLE_NATIVE, screen_index); + height = chains.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 nullptr; @@ -60,7 +60,7 @@ bgfx_target* target_reader::read_from_value(const Value& value, std::string pref break; } - return targets.create_target(target_name, bgfx::TextureFormat::RGBA8, width, height, mode, double_buffer, bilinear, scale, screen_index); + return chains.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) diff --git a/src/osd/modules/render/bgfx/targetreader.h b/src/osd/modules/render/bgfx/targetreader.h index abbc4f9a805..7edf5e456fa 100644 --- a/src/osd/modules/render/bgfx/targetreader.h +++ b/src/osd/modules/render/bgfx/targetreader.h @@ -16,13 +16,12 @@ #include "statereader.h" class bgfx_target; -class target_manager; -class osd_options; +class chain_manager; class target_reader : public state_reader { public: - static bgfx_target* 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, chain_manager& chains, uint32_t screen_index); private: static bool validate_parameters(const Value& value, std::string prefix);