From 825d575195d59f02e9685b33ea3cbbe32e405304 Mon Sep 17 00:00:00 2001 From: "therealmogminer@gmail.com" Date: Mon, 21 Mar 2016 03:43:02 +0100 Subject: Fix lots of issues with bgfx --- bgfx/chains/default.json | 8 +- bgfx/chains/hlsl.json | 14 +-- bgfx/chains/unfiltered.json | 8 +- bgfx/shaders/dx11/fs_blit.bin | Bin 40856 -> 40856 bytes bgfx/shaders/dx11/fs_color.bin | Bin 43257 -> 43257 bytes bgfx/shaders/dx11/fs_deconverge.bin | Bin 41060 -> 41060 bytes bgfx/shaders/dx11/fs_defocus.bin | Bin 45804 -> 45804 bytes bgfx/shaders/dx11/fs_distortion.bin | Bin 56045 -> 56045 bytes bgfx/shaders/dx11/fs_gui.bin | Bin 40856 -> 40856 bytes bgfx/shaders/dx11/fs_ntsc_decode.bin | Bin 58919 -> 58919 bytes bgfx/shaders/dx11/fs_ntsc_encode.bin | Bin 48331 -> 48331 bytes bgfx/shaders/dx11/fs_phosphor.bin | Bin 41094 -> 41094 bytes bgfx/shaders/dx11/fs_post.bin | Bin 55640 -> 55640 bytes bgfx/shaders/dx11/fs_screen.bin | Bin 40856 -> 40856 bytes bgfx/shaders/dx11/vs_blit.bin | Bin 38987 -> 38987 bytes bgfx/shaders/dx11/vs_color.bin | Bin 38987 -> 38987 bytes bgfx/shaders/dx11/vs_deconverge.bin | Bin 43788 -> 43788 bytes bgfx/shaders/dx11/vs_defocus.bin | Bin 38987 -> 38987 bytes bgfx/shaders/dx11/vs_distortion.bin | Bin 38987 -> 38987 bytes bgfx/shaders/dx11/vs_gui.bin | Bin 38987 -> 38987 bytes bgfx/shaders/dx11/vs_ntsc_decode.bin | Bin 38987 -> 38987 bytes bgfx/shaders/dx11/vs_ntsc_encode.bin | Bin 38987 -> 38987 bytes bgfx/shaders/dx11/vs_phosphor.bin | Bin 38987 -> 38987 bytes bgfx/shaders/dx11/vs_post.bin | Bin 41216 -> 41216 bytes bgfx/shaders/dx11/vs_screen.bin | Bin 38987 -> 38987 bytes scripts/src/osd/modules.lua | 1 + src/osd/modules/lib/osdobj_common.cpp | 4 +- src/osd/modules/render/bgfx/chain.cpp | 7 +- src/osd/modules/render/bgfx/chain.h | 6 +- src/osd/modules/render/bgfx/chainentry.cpp | 34 ++++--- src/osd/modules/render/bgfx/chainentry.h | 7 +- src/osd/modules/render/bgfx/chainentryreader.cpp | 75 +++++++++------ src/osd/modules/render/bgfx/chainentryreader.h | 2 +- src/osd/modules/render/bgfx/chainmanager.cpp | 22 ++++- src/osd/modules/render/bgfx/chainreader.cpp | 105 ++++++++------------- src/osd/modules/render/bgfx/chainreader.h | 5 +- src/osd/modules/render/bgfx/depthreader.cpp | 8 +- src/osd/modules/render/bgfx/depthreader.h | 4 +- src/osd/modules/render/bgfx/effectreader.cpp | 32 ++++--- src/osd/modules/render/bgfx/effectreader.h | 2 +- src/osd/modules/render/bgfx/entryuniformreader.cpp | 22 ++++- src/osd/modules/render/bgfx/entryuniformreader.h | 2 +- src/osd/modules/render/bgfx/inputpair.cpp | 9 +- src/osd/modules/render/bgfx/inputpair.h | 2 +- src/osd/modules/render/bgfx/paramreader.cpp | 22 +++-- src/osd/modules/render/bgfx/paramreader.h | 2 +- src/osd/modules/render/bgfx/paramuniformreader.cpp | 12 ++- src/osd/modules/render/bgfx/paramuniformreader.h | 2 +- src/osd/modules/render/bgfx/sliderreader.cpp | 69 ++++++++------ src/osd/modules/render/bgfx/sliderreader.h | 4 +- .../modules/render/bgfx/slideruniformreader.cpp | 12 ++- src/osd/modules/render/bgfx/slideruniformreader.h | 2 +- src/osd/modules/render/bgfx/statereader.h | 8 +- src/osd/modules/render/bgfx/suppressorreader.cpp | 22 +++-- src/osd/modules/render/bgfx/suppressorreader.h | 5 +- src/osd/modules/render/bgfx/target.cpp | 3 +- src/osd/modules/render/bgfx/target.h | 4 +- src/osd/modules/render/bgfx/targetmanager.cpp | 37 +++++++- src/osd/modules/render/bgfx/targetmanager.h | 11 ++- src/osd/modules/render/bgfx/targetreader.cpp | 87 +++++++++++++++++ src/osd/modules/render/bgfx/targetreader.h | 33 +++++++ src/osd/modules/render/bgfx/uniformreader.cpp | 25 +++-- src/osd/modules/render/bgfx/uniformreader.h | 17 +--- src/osd/modules/render/bgfx/valueuniformreader.cpp | 12 ++- src/osd/modules/render/bgfx/valueuniformreader.h | 2 +- src/osd/modules/render/drawbgfx.cpp | 82 ++++++++++------ src/osd/modules/render/drawbgfx.h | 5 +- 67 files changed, 542 insertions(+), 315 deletions(-) create mode 100644 src/osd/modules/render/bgfx/targetreader.cpp create mode 100644 src/osd/modules/render/bgfx/targetreader.h diff --git a/bgfx/chains/default.json b/bgfx/chains/default.json index fca46a0159e..f620ce93855 100644 --- a/bgfx/chains/default.json +++ b/bgfx/chains/default.json @@ -4,9 +4,6 @@ { "name": "temp", "mode": "guest", "bilinear": true - }, - { "name": "screen", - "mode": "native" } ], "passes": [ @@ -22,8 +19,7 @@ "input": [ { "sampler": "s_tex", "texture": "temp" } ], - "output": "screen" + "output": "output" } - ], - "output": "screen" + ] } \ No newline at end of file diff --git a/bgfx/chains/hlsl.json b/bgfx/chains/hlsl.json index 784a51c011b..a788235aa38 100644 --- a/bgfx/chains/hlsl.json +++ b/bgfx/chains/hlsl.json @@ -71,15 +71,6 @@ "mode": "guest", "prescale": true, "doublebuffer": true - }, - { "name": "previous", - "mode": "guest", - "prescale": true, - "doublebuffer": true - }, - { "name": "screen", - "mode": "native", - "doublebuffer": true } ], "passes": [ @@ -307,8 +298,7 @@ "input": [ { "sampler": "s_tex", "texture": "internal" } ], - "output": "screen" + "output": "output" } - ], - "output": "screen" + ] } \ No newline at end of file diff --git a/bgfx/chains/unfiltered.json b/bgfx/chains/unfiltered.json index 63eed75a575..f93eed2c722 100644 --- a/bgfx/chains/unfiltered.json +++ b/bgfx/chains/unfiltered.json @@ -4,9 +4,6 @@ { "name": "temp", "mode": "guest", "bilinear": false - }, - { "name": "screen", - "mode": "native" } ], "passes": [ @@ -22,8 +19,7 @@ "input": [ { "sampler": "s_tex", "texture": "temp" } ], - "output": "screen" + "output": "output" } - ], - "output": "screen" + ] } \ No newline at end of file diff --git a/bgfx/shaders/dx11/fs_blit.bin b/bgfx/shaders/dx11/fs_blit.bin index ffaaa190950..9b82df8d3bc 100644 Binary files a/bgfx/shaders/dx11/fs_blit.bin and b/bgfx/shaders/dx11/fs_blit.bin differ diff --git a/bgfx/shaders/dx11/fs_color.bin b/bgfx/shaders/dx11/fs_color.bin index 5cbf93eb345..388dd403690 100644 Binary files a/bgfx/shaders/dx11/fs_color.bin and b/bgfx/shaders/dx11/fs_color.bin differ diff --git a/bgfx/shaders/dx11/fs_deconverge.bin b/bgfx/shaders/dx11/fs_deconverge.bin index cfd2f01541b..7f114eb40de 100644 Binary files a/bgfx/shaders/dx11/fs_deconverge.bin and b/bgfx/shaders/dx11/fs_deconverge.bin differ diff --git a/bgfx/shaders/dx11/fs_defocus.bin b/bgfx/shaders/dx11/fs_defocus.bin index 27bae0bf11a..2b62ecfea50 100644 Binary files a/bgfx/shaders/dx11/fs_defocus.bin and b/bgfx/shaders/dx11/fs_defocus.bin differ diff --git a/bgfx/shaders/dx11/fs_distortion.bin b/bgfx/shaders/dx11/fs_distortion.bin index 77295d7a4b7..8bb9b1d8de9 100644 Binary files a/bgfx/shaders/dx11/fs_distortion.bin and b/bgfx/shaders/dx11/fs_distortion.bin differ diff --git a/bgfx/shaders/dx11/fs_gui.bin b/bgfx/shaders/dx11/fs_gui.bin index 5f452bdc4f2..7091eac73e3 100644 Binary files a/bgfx/shaders/dx11/fs_gui.bin and b/bgfx/shaders/dx11/fs_gui.bin differ diff --git a/bgfx/shaders/dx11/fs_ntsc_decode.bin b/bgfx/shaders/dx11/fs_ntsc_decode.bin index 327d86d1fce..8ba3903ec0a 100644 Binary files a/bgfx/shaders/dx11/fs_ntsc_decode.bin and b/bgfx/shaders/dx11/fs_ntsc_decode.bin differ diff --git a/bgfx/shaders/dx11/fs_ntsc_encode.bin b/bgfx/shaders/dx11/fs_ntsc_encode.bin index 05f2161a539..0b9a2ef1c2d 100644 Binary files a/bgfx/shaders/dx11/fs_ntsc_encode.bin and b/bgfx/shaders/dx11/fs_ntsc_encode.bin differ diff --git a/bgfx/shaders/dx11/fs_phosphor.bin b/bgfx/shaders/dx11/fs_phosphor.bin index 1a9430af3ad..4e9463b9e43 100644 Binary files a/bgfx/shaders/dx11/fs_phosphor.bin and b/bgfx/shaders/dx11/fs_phosphor.bin differ diff --git a/bgfx/shaders/dx11/fs_post.bin b/bgfx/shaders/dx11/fs_post.bin index b0f7026a48b..2966d31caed 100644 Binary files a/bgfx/shaders/dx11/fs_post.bin and b/bgfx/shaders/dx11/fs_post.bin differ diff --git a/bgfx/shaders/dx11/fs_screen.bin b/bgfx/shaders/dx11/fs_screen.bin index e1984860d6d..77db0e11cdf 100644 Binary files a/bgfx/shaders/dx11/fs_screen.bin and b/bgfx/shaders/dx11/fs_screen.bin differ diff --git a/bgfx/shaders/dx11/vs_blit.bin b/bgfx/shaders/dx11/vs_blit.bin index 5a91e418e0e..921983524a6 100644 Binary files a/bgfx/shaders/dx11/vs_blit.bin and b/bgfx/shaders/dx11/vs_blit.bin differ diff --git a/bgfx/shaders/dx11/vs_color.bin b/bgfx/shaders/dx11/vs_color.bin index 1abc2ad4ee4..e8537348c73 100644 Binary files a/bgfx/shaders/dx11/vs_color.bin and b/bgfx/shaders/dx11/vs_color.bin differ diff --git a/bgfx/shaders/dx11/vs_deconverge.bin b/bgfx/shaders/dx11/vs_deconverge.bin index e23c0d8a2c4..04b7f26d457 100644 Binary files a/bgfx/shaders/dx11/vs_deconverge.bin and b/bgfx/shaders/dx11/vs_deconverge.bin differ diff --git a/bgfx/shaders/dx11/vs_defocus.bin b/bgfx/shaders/dx11/vs_defocus.bin index 36da8e24752..48e32ee5d8c 100644 Binary files a/bgfx/shaders/dx11/vs_defocus.bin and b/bgfx/shaders/dx11/vs_defocus.bin differ diff --git a/bgfx/shaders/dx11/vs_distortion.bin b/bgfx/shaders/dx11/vs_distortion.bin index 4f021030a66..d56ecb58e4f 100644 Binary files a/bgfx/shaders/dx11/vs_distortion.bin and b/bgfx/shaders/dx11/vs_distortion.bin differ diff --git a/bgfx/shaders/dx11/vs_gui.bin b/bgfx/shaders/dx11/vs_gui.bin index f1707c28ed0..a534317dfb9 100644 Binary files a/bgfx/shaders/dx11/vs_gui.bin and b/bgfx/shaders/dx11/vs_gui.bin differ diff --git a/bgfx/shaders/dx11/vs_ntsc_decode.bin b/bgfx/shaders/dx11/vs_ntsc_decode.bin index 62adb591763..1d83e3d9ea4 100644 Binary files a/bgfx/shaders/dx11/vs_ntsc_decode.bin and b/bgfx/shaders/dx11/vs_ntsc_decode.bin differ diff --git a/bgfx/shaders/dx11/vs_ntsc_encode.bin b/bgfx/shaders/dx11/vs_ntsc_encode.bin index c9695a27aea..d58e84749dc 100644 Binary files a/bgfx/shaders/dx11/vs_ntsc_encode.bin and b/bgfx/shaders/dx11/vs_ntsc_encode.bin differ diff --git a/bgfx/shaders/dx11/vs_phosphor.bin b/bgfx/shaders/dx11/vs_phosphor.bin index 18d3a86a8b4..72def3ab605 100644 Binary files a/bgfx/shaders/dx11/vs_phosphor.bin and b/bgfx/shaders/dx11/vs_phosphor.bin differ diff --git a/bgfx/shaders/dx11/vs_post.bin b/bgfx/shaders/dx11/vs_post.bin index fa5c59c6818..3495e27a797 100644 Binary files a/bgfx/shaders/dx11/vs_post.bin and b/bgfx/shaders/dx11/vs_post.bin differ diff --git a/bgfx/shaders/dx11/vs_screen.bin b/bgfx/shaders/dx11/vs_screen.bin index 96dc86dc5f0..320f9d80e71 100644 Binary files a/bgfx/shaders/dx11/vs_screen.bin and b/bgfx/shaders/dx11/vs_screen.bin differ diff --git a/scripts/src/osd/modules.lua b/scripts/src/osd/modules.lua index ee6907f91bc..6f4d0a7f674 100644 --- a/scripts/src/osd/modules.lua +++ b/scripts/src/osd/modules.lua @@ -146,6 +146,7 @@ function osdmodulesbuild() MAME_DIR .. "src/osd/modules/render/bgfx/suppressor.cpp", MAME_DIR .. "src/osd/modules/render/bgfx/suppressorreader.cpp", MAME_DIR .. "src/osd/modules/render/bgfx/target.cpp", + MAME_DIR .. "src/osd/modules/render/bgfx/targetreader.cpp", MAME_DIR .. "src/osd/modules/render/bgfx/targetmanager.cpp", MAME_DIR .. "src/osd/modules/render/bgfx/texture.cpp", MAME_DIR .. "src/osd/modules/render/bgfx/texturemanager.cpp", diff --git a/src/osd/modules/lib/osdobj_common.cpp b/src/osd/modules/lib/osdobj_common.cpp index df6cdeedffc..d8200463e62 100644 --- a/src/osd/modules/lib/osdobj_common.cpp +++ b/src/osd/modules/lib/osdobj_common.cpp @@ -146,8 +146,8 @@ const options_entry osd_options::s_option_entries[] = { OSDOPTION_BGFX_DEBUG, "0", OPTION_BOOLEAN, "enable BGFX debugging statistics" }, { OSDOPTION_BGFX_SCREEN_CHAIN, "default", OPTION_STRING, "screen chain JSON file to use" }, { OSDOPTION_BGFX_SHADOW_MASK, "shadow-mask.png", OPTION_STRING, "shadow mask texture name" }, - { OSDOPTION_BGFX_PRESCALE_X, "1", OPTION_INTEGER, "x prescale" }, - { OSDOPTION_BGFX_PRESCALE_Y, "1", OPTION_INTEGER, "y prescale" }, + { OSDOPTION_BGFX_PRESCALE_X, "2", OPTION_INTEGER, "x prescale" }, + { OSDOPTION_BGFX_PRESCALE_Y, "2", OPTION_INTEGER, "y prescale" }, // End of list { nullptr } diff --git a/src/osd/modules/render/bgfx/chain.cpp b/src/osd/modules/render/bgfx/chain.cpp index 018c260f1fb..44cc000c8fa 100644 --- a/src/osd/modules/render/bgfx/chain.cpp +++ b/src/osd/modules/render/bgfx/chain.cpp @@ -19,13 +19,12 @@ #include "chain.h" -bgfx_chain::bgfx_chain(std::string name, std::string author, std::vector sliders, std::vector params, std::vector entries, std::string output) +bgfx_chain::bgfx_chain(std::string name, std::string author, std::vector sliders, std::vector params, std::vector entries) : m_name(name) , m_author(author) , m_sliders(sliders) , m_params(params) , m_entries(entries) - , m_output(output) , m_current_time(0) { for (bgfx_slider* slider : m_sliders) @@ -50,7 +49,7 @@ bgfx_chain::~bgfx_chain() } } -void bgfx_chain::process(render_primitive* prim, int view, texture_manager& textures, osd_window& window, uint64_t blend) +void bgfx_chain::process(render_primitive* prim, int view, int screen, texture_manager& textures, osd_window& window, uint64_t blend) { int current_view = view; uint16_t screen_width = window.get_size().width(); @@ -67,7 +66,7 @@ void bgfx_chain::process(render_primitive* prim, int view, texture_manager& text { if (!entry->skip()) { - entry->submit(current_view, prim, textures, screen_width, screen_height, rotation_type, swap_xy, blend); + entry->submit(current_view, prim, textures, screen_width, screen_height, rotation_type, swap_xy, blend, screen); current_view++; } } diff --git a/src/osd/modules/render/bgfx/chain.h b/src/osd/modules/render/bgfx/chain.h index 7ea1b1170a4..13283f9ba08 100644 --- a/src/osd/modules/render/bgfx/chain.h +++ b/src/osd/modules/render/bgfx/chain.h @@ -26,14 +26,13 @@ class osd_window; class bgfx_chain { public: - bgfx_chain(std::string name, std::string author, std::vector sliders, std::vector params, std::vector entries, std::string output); + bgfx_chain(std::string name, std::string author, std::vector sliders, std::vector params, std::vector entries); ~bgfx_chain(); - void process(render_primitive* prim, int view, texture_manager& textures, osd_window &window, uint64_t blend = 0L); + void process(render_primitive* prim, int view, int screen, texture_manager& textures, osd_window &window, uint64_t blend = 0L); // Getters std::vector& sliders() { return m_sliders; } - std::string output() const { return m_output; } uint32_t applicable_passes(); private: @@ -43,7 +42,6 @@ private: std::vector m_params; std::vector m_entries; std::map m_slider_map; - std::string m_output; int64_t m_current_time; }; diff --git a/src/osd/modules/render/bgfx/chainentry.cpp b/src/osd/modules/render/bgfx/chainentry.cpp index 7fde23992e8..526b40a978d 100644 --- a/src/osd/modules/render/bgfx/chainentry.cpp +++ b/src/osd/modules/render/bgfx/chainentry.cpp @@ -31,7 +31,7 @@ bgfx_chain_entry::bgfx_chain_entry(std::string name, bgfx_effect* effect, std::v , m_inputs(inputs) , m_uniforms(uniforms) , m_targets(targets) - , m_output(output) + , m_output(output) { } @@ -44,18 +44,18 @@ bgfx_chain_entry::~bgfx_chain_entry() m_uniforms.clear(); } -void bgfx_chain_entry::submit(int view, render_primitive* prim, texture_manager& textures, uint16_t screen_width, uint16_t screen_height, uint32_t rotation_type, bool swap_xy, uint64_t blend) +void bgfx_chain_entry::submit(int view, render_primitive* prim, texture_manager& textures, uint16_t screen_width, uint16_t screen_height, uint32_t rotation_type, bool swap_xy, uint64_t blend, int32_t screen) { bgfx::setViewSeq(view, true); - if (!setup_view(view, screen_width, screen_height)) + if (!setup_view(view, screen_width, screen_height, screen)) { return; } for (bgfx_input_pair input : m_inputs) { - input.bind(m_effect, textures); + input.bind(m_effect, textures, screen); } bgfx::TransientVertexBuffer buffer; @@ -74,9 +74,14 @@ void bgfx_chain_entry::submit(int view, render_primitive* prim, texture_manager& m_effect->submit(view, blend); - if (m_targets.target(m_output) != nullptr) + std::string output_name = m_output; + if (output_name == "output" || output_name == "previous") { - m_targets.target(m_output)->page_flip(); + output_name = output_name + std::to_string(screen); + } + if (m_targets.target(output_name) != nullptr) + { + m_targets.target(output_name)->page_flip(); } } @@ -143,14 +148,19 @@ void bgfx_chain_entry::setup_auto_uniforms(render_primitive* prim, texture_manag setup_swapxy_uniform(swap_xy); } -bool bgfx_chain_entry::setup_view(int view, uint16_t screen_width, uint16_t screen_height) +bool bgfx_chain_entry::setup_view(int view, uint16_t screen_width, uint16_t screen_height, int32_t screen) { bgfx::FrameBufferHandle handle = BGFX_INVALID_HANDLE; uint16_t width = screen_width; uint16_t height = screen_height; - if (m_targets.target(m_output) != nullptr) + std::string output_name = m_output; + if (output_name == "output" || output_name == "previous") + { + output_name = output_name + std::to_string(screen); + } + if (m_targets.target(output_name) != nullptr) { - bgfx_target* output = m_targets.target(m_output); + bgfx_target* output = m_targets.target(output_name); if (output->width() == 0) { return false; @@ -164,7 +174,7 @@ bool bgfx_chain_entry::setup_view(int view, uint16_t screen_width, uint16_t scre bgfx::setViewRect(view, 0, 0, width, height); float projMat[16]; - bx::mtxOrtho(projMat, 0.0f, screen_width, screen_height, 0.0f, 0.0f, 100.0f); + bx::mtxOrtho(projMat, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 100.0f); bgfx::setViewTransform(view, nullptr, projMat); bgfx::setViewClear(view, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x000000ff, 1.0f, 0); @@ -184,8 +194,8 @@ void bgfx_chain_entry::put_screen_buffer(render_primitive* prim, bgfx::Transient ScreenVertex* vertex = reinterpret_cast(buffer->data); - float x[4] = { prim->bounds.x0, prim->bounds.x1, prim->bounds.x0, prim->bounds.x1 }; - float y[4] = { prim->bounds.y0, prim->bounds.y0, prim->bounds.y1, prim->bounds.y1 }; + float x[4] = { 0, 1, 0, 1 }; + float y[4] = { 0, 0, 1, 1 }; float u[4] = { 0, 1, 0, 1 }; float v[4] = { 0, 0, 1, 1 }; diff --git a/src/osd/modules/render/bgfx/chainentry.h b/src/osd/modules/render/bgfx/chainentry.h index 83f834cca15..15606ae8b79 100644 --- a/src/osd/modules/render/bgfx/chainentry.h +++ b/src/osd/modules/render/bgfx/chainentry.h @@ -36,11 +36,10 @@ public: bgfx_chain_entry(std::string name, bgfx_effect* effect, 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, uint32_t rotation_type, bool swap_xy, uint64_t blend); + void submit(int view, render_primitive* prim, texture_manager& textures, uint16_t screen_width, uint16_t screen_height, uint32_t rotation_type, bool swap_xy, uint64_t blend, int32_t screen); // Getters std::string name() const { return m_name; } - bgfx_target* target() const { return m_targets.target(m_output); } bool skip(); private: @@ -50,7 +49,7 @@ private: void setup_rotationtype_uniform(uint32_t rotation_type); void setup_swapxy_uniform(bool swap_xy); - bool setup_view(int view, uint16_t screen_width, uint16_t screen_height); + bool setup_view(int view, uint16_t screen_width, uint16_t screen_height, int32_t screen); void put_screen_buffer(render_primitive* prim, bgfx::TransientVertexBuffer* buffer); std::string m_name; @@ -59,7 +58,7 @@ private: std::vector m_inputs; std::vector m_uniforms; target_manager& m_targets; - std::string m_output; + std::string m_output; }; #endif // __DRAWBGFX_CHAIN_ENTRY__ diff --git a/src/osd/modules/render/bgfx/chainentryreader.cpp b/src/osd/modules/render/bgfx/chainentryreader.cpp index de3471a4449..e98b704a853 100644 --- a/src/osd/modules/render/bgfx/chainentryreader.cpp +++ b/src/osd/modules/render/bgfx/chainentryreader.cpp @@ -29,7 +29,11 @@ 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) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + printf("Failed validation\n"); + return nullptr; + } bgfx_effect* effect = effects.effect(value["effect"].GetString()); std::string name = value["name"].GetString(); @@ -37,14 +41,13 @@ bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::s std::vector inputs; if (value.HasMember("input")) { - READER_ASSERT(value["input"].IsArray(), (prefix + "Chain entry '" + name + "': value 'input' must be an array\n").c_str()); const Value& input_array = value["input"]; for (UINT32 i = 0; i < input_array.Size(); i++) { - READER_ASSERT(input_array[i].HasMember("sampler"), (prefix + "input[" + std::to_string(i) + ": Must have string value 'sampler' (what sampler are we binding to?)\n").c_str()); - READER_ASSERT(input_array[i]["sampler"].IsString(), (prefix + "input[" + std::to_string(i) + ": Value 'sampler' must be a string\n").c_str()); - READER_ASSERT(input_array[i].HasMember("texture"), (prefix + "input[" + std::to_string(i) + ": Must have string value 'texture' (what texture are we using?)\n").c_str()); - READER_ASSERT(input_array[i]["texture"].IsString(), (prefix + "input[" + std::to_string(i) + ": Value 'texture' must be a string\n").c_str()); + if (!READER_CHECK(input_array[i].HasMember("sampler"), (prefix + "input[" + std::to_string(i) + ": Must have string value 'sampler' (what sampler are we binding to?)\n").c_str())) return nullptr; + if (!READER_CHECK(input_array[i]["sampler"].IsString(), (prefix + "input[" + std::to_string(i) + ": Value 'sampler' must be a string\n").c_str())) return nullptr; + if (!READER_CHECK(input_array[i].HasMember("texture"), (prefix + "input[" + std::to_string(i) + ": Must have string value 'texture' (what texture are we using?)\n").c_str())) return nullptr; + if (!READER_CHECK(input_array[i]["texture"].IsString(), (prefix + "input[" + std::to_string(i) + ": Value 'texture' must be a string\n").c_str())) return nullptr; std::string sampler = input_array[i]["sampler"].GetString(); std::string texture = input_array[i]["texture"].GetString(); inputs.push_back(bgfx_input_pair(i, sampler, texture)); @@ -54,55 +57,69 @@ bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::s std::vector uniforms; if (value.HasMember("uniforms")) { - READER_ASSERT(value["uniforms"].IsArray(), (prefix + "Chain entry '" + name + "': value 'uniforms' must be an array\n").c_str()); const Value& uniform_array = value["uniforms"]; for (UINT32 i = 0; i < uniform_array.Size(); i++) { - uniforms.push_back(entry_uniform_reader::read_from_value(uniform_array[i], prefix + "uniforms[" + std::to_string(i) + "]: ", effect, sliders, params)); + bgfx_entry_uniform* uniform = entry_uniform_reader::read_from_value(uniform_array[i], prefix + "uniforms[" + std::to_string(i) + "]: ", effect, sliders, params); + if (uniform == nullptr) + { + for (bgfx_entry_uniform* existing_uniform : uniforms) delete existing_uniform; + return nullptr; + } + uniforms.push_back(uniform); } } std::vector suppressors; if (value.HasMember("disablewhen")) { - READER_ASSERT(value["disablewhen"].IsArray(), (prefix + "Chain entry '" + name + "': value 'disablewhen' must be an array\n").c_str()); const Value& suppressor_array = value["disablewhen"]; for (UINT32 i = 0; i < suppressor_array.Size(); i++) { - suppressors.push_back(suppressor_reader::read_from_value(suppressor_array[i], prefix, sliders)); + bgfx_suppressor* suppressor = suppressor_reader::read_from_value(suppressor_array[i], prefix, sliders); + if (suppressor == nullptr) + { + for (bgfx_entry_uniform* uniform : uniforms) delete uniform; + for (bgfx_suppressor* existing_suppressor : suppressors) delete existing_suppressor; + return nullptr; + } + suppressors.push_back(suppressor); } } if (value.HasMember("textures")) { - READER_ASSERT(value["textures"].IsArray(), (prefix + "Chain entry '" + name + "': value 'textures' must be an array\n").c_str()); const Value& texture_array = value["textures"]; for (UINT32 i = 0; i < texture_array.Size(); i++) { std::string texture_path = std::string(options.bgfx_path()) + "/artwork/"; + if (!READER_CHECK(texture_array[i].IsString(), (prefix + "textures[" + std::to_string(i) + "]: Value must be a string\n").c_str())) + { + for (bgfx_entry_uniform* uniform : uniforms) delete uniform; + for (bgfx_suppressor* suppressor : suppressors) delete suppressor; + return nullptr; + } std::string texture_name = texture_array[i].GetString(); - + textures.create_png_texture(texture_path, texture_name, texture_name); } } - std::string output_name = value["output"].GetString(); - if (output_name != std::string("backbuffer")) - { - return new bgfx_chain_entry(name, effect, suppressors, inputs, uniforms, targets, output_name); - } - else - { - return new bgfx_chain_entry(name, effect, suppressors, inputs, uniforms, targets, "none"); - } + std::string output = value["output"].GetString(); + return new bgfx_chain_entry(name, effect, suppressors, inputs, uniforms, targets, output); } -void chain_entry_reader::validate_parameters(const Value& value, std::string prefix) +bool chain_entry_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("effect"), (prefix + "Must have string value 'effect' (what effect does this entry use?)\n").c_str()); - READER_ASSERT(value["effect"].IsString(), (prefix + "Value 'effect' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("name"), (prefix + "Must have string value 'effect' (what effect does this entry use?)\n").c_str()); - READER_ASSERT(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("output"), (prefix + "Must have string value 'output' (what target contains the result of this entry?)\n").c_str()); - READER_ASSERT(value["output"].IsString(), (prefix + "Value 'output' must be a string\n").c_str()); -} + if (!READER_CHECK(value.HasMember("effect"), (prefix + "Must have string value 'effect' (what effect does this entry use?)\n").c_str())) return false; + if (!READER_CHECK(value["effect"].IsString(), (prefix + "Value 'effect' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("name"), (prefix + "Must have string value 'effect' (what effect does this entry use?)\n").c_str())) return false; + if (!READER_CHECK(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("output"), (prefix + "Must have string value 'offset' (what target are we rendering to?)\n").c_str())) return false; + if (!READER_CHECK(value["output"].IsString(), (prefix + "Value 'output' must be a string\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("input") || value["input"].IsArray(), (prefix + "Value 'input' must be an array\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("uniforms") || value["uniforms"].IsArray(), (prefix + "Value 'uniforms' must be an array\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("disablewhen") || value["disablewhen"].IsArray(), (prefix + "Value 'disablewhen' must be an array\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("textures") || value["textures"].IsArray(), (prefix + "Value 'textures' must be an array\n").c_str())) return false; + return true; +} \ No newline at end of file diff --git a/src/osd/modules/render/bgfx/chainentryreader.h b/src/osd/modules/render/bgfx/chainentryreader.h index f49cb3bdacc..a6001ca60eb 100644 --- a/src/osd/modules/render/bgfx/chainentryreader.h +++ b/src/osd/modules/render/bgfx/chainentryreader.h @@ -29,7 +29,7 @@ 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); private: - static void validate_parameters(const Value& value, std::string prefix); + static bool validate_parameters(const Value& value, std::string prefix); }; #endif // __DRAWBGFX_CHAIN_ENTRY_READER__ diff --git a/src/osd/modules/render/bgfx/chainmanager.cpp b/src/osd/modules/render/bgfx/chainmanager.cpp index 23358109f6a..d650e2dadce 100644 --- a/src/osd/modules/render/bgfx/chainmanager.cpp +++ b/src/osd/modules/render/bgfx/chainmanager.cpp @@ -12,6 +12,7 @@ #include "emu.h" #include +#include #include #include @@ -51,7 +52,11 @@ bgfx_chain* chain_manager::load_chain(std::string name, running_machine& machine std::string path = std::string(m_options.bgfx_path()) + "/chains/" + name; bx::CrtFileReader reader; - bx::open(&reader, path.c_str()); + if (!bx::open(&reader, path.c_str())) + { + printf("Unable to open chain file %s, falling back to no post processing\n", path.c_str()); + return nullptr; + } int32_t size(bx::getSize(&reader)); @@ -62,8 +67,23 @@ bgfx_chain* chain_manager::load_chain(std::string name, running_machine& machine Document document; document.Parse<0>(data); + + if (document.HasParseError()) + { + std::string error(GetParseError_En(document.GetParseError())); + printf("Unable to parse chain %s. Errors returned:\n", path.c_str()); + printf("%s\n", error.c_str()); + return nullptr; + } + bgfx_chain* chain = chain_reader::read_from_value(document, name + ": ", m_options, machine, window_index, m_textures, m_targets, m_effects, m_width, m_height); + if (chain == nullptr) + { + printf("Unable to load chain %s, falling back to no post processing\n", path.c_str()); + return nullptr; + } + m_chains[name + std::to_string(window_index)] = chain; return chain; diff --git a/src/osd/modules/render/bgfx/chainreader.cpp b/src/osd/modules/render/bgfx/chainreader.cpp index 0892523faa6..79ab78cdaa2 100644 --- a/src/osd/modules/render/bgfx/chainreader.cpp +++ b/src/osd/modules/render/bgfx/chainreader.cpp @@ -13,25 +13,23 @@ #include "emu.h" #include +#include "chainreader.h" + #include "chain.h" #include "sliderreader.h" #include "paramreader.h" #include "chainentryreader.h" +#include "targetreader.h" #include "targetmanager.h" -#include "chainreader.h" -#include "target.h" #include "slider.h" #include "parameter.h" -const chain_reader::string_to_enum chain_reader::STYLE_NAMES[chain_reader::STYLE_COUNT] = { - { "guest", TARGET_STYLE_GUEST }, - { "native", TARGET_STYLE_NATIVE }, - { "custom", TARGET_STYLE_CUSTOM } -}; - bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix, osd_options& options, running_machine& machine, uint32_t window_index, texture_manager& textures, target_manager& targets, effect_manager& effects, uint32_t screen_width, uint32_t screen_height) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } std::string name = value["name"].GetString(); std::string author = value["author"].GetString(); @@ -44,6 +42,10 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix 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); + if (expanded_sliders.size() == 0) + { + return nullptr; + } for (bgfx_slider* slider : expanded_sliders) { sliders.push_back(slider); @@ -62,11 +64,15 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix std::vector parameters; if (value.HasMember("parameters")) { - READER_ASSERT(value["parameters"].IsArray(), (prefix + "Value 'parameters' must be an array\n").c_str()); const Value& param_array = value["parameters"]; for (UINT32 i = 0; i < param_array.Size(); i++) { - parameters.push_back(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) + "]; ", window_index); + if (parameter == nullptr) + { + return nullptr; + } + parameters.push_back(parameter); } } @@ -80,56 +86,14 @@ bgfx_chain* chain_reader::read_from_value(const Value& value, std::string prefix // Create targets if (value.HasMember("targets")) { - READER_ASSERT(value["targets"].IsArray(), (prefix + "Value 'targets' must be an array\n").c_str()); const Value& target_array = value["targets"]; // TODO: Move into its own reader for (UINT32 i = 0; i < target_array.Size(); i++) { - READER_ASSERT(target_array[i].HasMember("name"), (prefix + "targets[" + std::to_string(i) + "]: Must have string value 'name'\n").c_str()); - READER_ASSERT(target_array[i]["name"].IsString(), (prefix + "targets[" + std::to_string(i) + "]: Value 'name' must be a string\n").c_str()); - READER_ASSERT(target_array[i].HasMember("mode"), (prefix + "targets[" + std::to_string(i) + "]: Must have string enum 'mode'\n").c_str()); - READER_ASSERT(target_array[i]["mode"].IsString(), (prefix + "targets[" + std::to_string(i) + "]: Value 'mode' must be a string (what screens does this apply to?)\n").c_str()); - READER_ASSERT(!target_array[i].HasMember("bilinear") || target_array[i]["bilinear"].IsBool(), (prefix + "targets[" + std::to_string(i) + "]: Value 'bilinear' must be a boolean\n").c_str()); - READER_ASSERT(!target_array[i].HasMember("doublebuffer") || target_array[i]["doublebuffer"].IsBool(), (prefix + "targets[" + std::to_string(i) + "]: Value 'doublebuffer' must be a boolean\n").c_str()); - READER_ASSERT(!target_array[i].HasMember("prescale") || target_array[i]["prescale"].IsBool(), (prefix + "targets[" + std::to_string(i) + "]: Value 'prescale' must be a boolean\n").c_str()); - - std::string target_name = target_array[i]["name"].GetString(); - uint32_t mode = uint32_t(get_enum_from_value(target_array[i], "mode", TARGET_STYLE_NATIVE, STYLE_NAMES, STYLE_COUNT)); - bool bilinear = get_bool(target_array[i], "bilinear", true); - bool double_buffer = get_bool(target_array[i], "doublebuffer", true); - bool prescale = get_bool(target_array[i], "prescale", false); - - uint16_t width = 0; - uint16_t height = 0; - switch (mode) + if (!target_reader::read_from_value(target_array[i], prefix + "targets[" + std::to_string(i) + "]: ", targets, options, screen_width, screen_height)) { - case TARGET_STYLE_GUEST: - width = targets.guest_width(); - height = targets.guest_height(); - break; - case TARGET_STYLE_NATIVE: - width = screen_width; - height = screen_height; - break; - case TARGET_STYLE_CUSTOM: - READER_ASSERT(target_array[i].HasMember("width"), (prefix + "Target '" + target_name + "': Must have numeric value 'width'\n").c_str()); - READER_ASSERT(target_array[i]["width"].IsNumber(), (prefix + "Target '" + target_name + "': Value 'width' must be a number\n").c_str()); - READER_ASSERT(target_array[i].HasMember("height"), (prefix + "Target '" + target_name + "': Must have numeric value 'height'\n").c_str()); - READER_ASSERT(target_array[i]["height"].IsNumber(), (prefix + "Target '" + target_name + "': Value 'height' must be a number\n").c_str()); - width = uint32_t(target_array[i]["width"].GetDouble()); - height = uint32_t(target_array[i]["height"].GetDouble()); - break; + return nullptr; } - - uint32_t prescale_x = 1; - uint32_t prescale_y = 1; - if (prescale) - { - prescale_x = options.bgfx_prescale_x(); - prescale_y = options.bgfx_prescale_y(); - } - - targets.create_target(target_name, bgfx::TextureFormat::RGBA8, width, height, prescale_x, prescale_y, mode, double_buffer, bilinear); } } @@ -140,23 +104,28 @@ 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++) { - entries.push_back(chain_entry_reader::read_from_value(entry_array[i], prefix + "passes[" + std::to_string(i) + "]: ", options, textures, targets, effects, slider_map, param_map)); + 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); + if (entry == nullptr) + { + return nullptr; + } + entries.push_back(entry); } } - std::string output = value["output"].GetString(); - - return new bgfx_chain(name, author, sliders, parameters, entries, output); + return new bgfx_chain(name, author, sliders, parameters, entries); } -void chain_reader::validate_parameters(const Value& value, std::string prefix) +bool chain_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str()); - READER_ASSERT(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("author"), (prefix + "Must have string value 'author'\n").c_str()); - READER_ASSERT(value["author"].IsString(), (prefix + "Value 'author' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("passes"), (prefix + "Must have array value 'passes'\n").c_str()); - READER_ASSERT(value["passes"].IsArray(), (prefix + "Value 'passes' must be an array\n").c_str()); - READER_ASSERT(value.HasMember("output"), (prefix + "Must have string value 'output'\n").c_str()); - READER_ASSERT(value["output"].IsString(), (prefix + "Value 'output' must be a string\n").c_str()); + if (!READER_CHECK(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str())) return false; + if (!READER_CHECK(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("author"), (prefix + "Must have string value 'author'\n").c_str())) return false; + if (!READER_CHECK(value["author"].IsString(), (prefix + "Value 'author' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("passes"), (prefix + "Must have array value 'passes'\n").c_str())) return false; + if (!READER_CHECK(value["passes"].IsArray(), (prefix + "Value 'passes' must be an array\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("sliders") || value["sliders"].IsArray(), (prefix + "Value 'sliders' must be an array\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("parameters") || value["parameters"].IsArray(), (prefix + "Value 'parameters' must be an array\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("targets") || value["targets"].IsArray(), (prefix + "Value 'targets' must be an array\n").c_str())) return false; + return true; } diff --git a/src/osd/modules/render/bgfx/chainreader.h b/src/osd/modules/render/bgfx/chainreader.h index f9bbbdf4b2e..78e3d677a04 100644 --- a/src/osd/modules/render/bgfx/chainreader.h +++ b/src/osd/modules/render/bgfx/chainreader.h @@ -24,10 +24,7 @@ public: static bgfx_chain* read_from_value(const Value& value, std::string prefix, osd_options& options, running_machine& machine, uint32_t window_index, texture_manager& textures, target_manager& targets, effect_manager& effects, uint32_t screen_width, uint32_t screen_height); private: - static void validate_parameters(const Value& value, std::string prefix); - - static const int STYLE_COUNT = 3; - static const string_to_enum STYLE_NAMES[STYLE_COUNT]; + static bool validate_parameters(const Value& value, std::string prefix); }; #endif // __DRAWBGFX_CHAIN_READER__ diff --git a/src/osd/modules/render/bgfx/depthreader.cpp b/src/osd/modules/render/bgfx/depthreader.cpp index cdcfa1b2046..e904604b84d 100644 --- a/src/osd/modules/render/bgfx/depthreader.cpp +++ b/src/osd/modules/render/bgfx/depthreader.cpp @@ -21,13 +21,13 @@ const depth_reader::string_to_enum depth_reader::FUNCTION_NAMES[depth_reader::FU { "always", BGFX_STATE_DEPTH_TEST_ALWAYS } }; -uint64_t depth_reader::read_from_value(const Value& value) +uint64_t depth_reader::read_from_value(const Value& value, std::string prefix) { uint64_t write_enable = 0; - if (value.HasMember("writeEnable")) + if (value.HasMember("writeenable")) { - assert(value["writeEnable"].IsBool()); - write_enable = value["writeEnable"].GetBool() ? BGFX_STATE_DEPTH_WRITE: 0; + if (!READER_CHECK(value["writeenable"].IsBool(), (prefix + "Value 'writeenable' must be a boolean\n").c_str())) return 0; + write_enable = value["writeenable"].GetBool() ? BGFX_STATE_DEPTH_WRITE: 0; } uint64_t function = get_enum_from_value(value, "function", BGFX_STATE_DEPTH_TEST_ALWAYS, FUNCTION_NAMES, FUNCTION_COUNT); diff --git a/src/osd/modules/render/bgfx/depthreader.h b/src/osd/modules/render/bgfx/depthreader.h index 761a1653323..9e2c99a0b29 100644 --- a/src/osd/modules/render/bgfx/depthreader.h +++ b/src/osd/modules/render/bgfx/depthreader.h @@ -11,11 +11,13 @@ #ifndef __DRAWBGFX_DEPTH_READER__ #define __DRAWBGFX_DEPTH_READER__ +#include + #include "statereader.h" class depth_reader : public state_reader { public: - static uint64_t read_from_value(const Value& value); + static uint64_t read_from_value(const Value& value, std::string prefix); private: static const int FUNCTION_COUNT = 8; diff --git a/src/osd/modules/render/bgfx/effectreader.cpp b/src/osd/modules/render/bgfx/effectreader.cpp index cc997358f6f..80a8b73abed 100644 --- a/src/osd/modules/render/bgfx/effectreader.cpp +++ b/src/osd/modules/render/bgfx/effectreader.cpp @@ -24,14 +24,17 @@ bgfx_effect* effect_reader::read_from_value(const Value& value, std::string prefix, shader_manager& shaders) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } uint64_t blend = 0; if (value.HasMember("blend")) { blend = blend_reader::read_from_value(value["blend"]); } - uint64_t depth = depth_reader::read_from_value(value["depth"]); + uint64_t depth = depth_reader::read_from_value(value["depth"], prefix + "depth: "); uint64_t cull = cull_reader::read_from_value(value["cull"]); uint64_t write = write_reader::read_from_value(value["write"]); @@ -39,7 +42,7 @@ bgfx_effect* effect_reader::read_from_value(const Value& value, std::string pref const Value& uniform_array = value["uniforms"]; for (UINT32 i = 0; i < uniform_array.Size(); i++) { - uniforms.push_back(uniform_reader::read_from_value(uniform_array[i])); + uniforms.push_back(uniform_reader::read_from_value(uniform_array[i], prefix + "uniforms[" + std::to_string(i) + "]: ")); } std::string vertex_name(value["vertex"].GetString()); @@ -59,16 +62,17 @@ bgfx_effect* effect_reader::read_from_value(const Value& value, std::string pref return new bgfx_effect(blend | depth | cull | write, vertex_shader, fragment_shader, uniforms); } -void effect_reader::validate_parameters(const Value& value, std::string prefix) +bool effect_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("depth"), (prefix + "Must have object value 'depth' (what are our Z-buffer settings?)\n").c_str()); - READER_ASSERT(value.HasMember("cull"), (prefix + "Must have object value 'cull' (do we cull triangles based on winding?)\n").c_str()); - READER_ASSERT(value.HasMember("write"), (prefix + "Must have object value 'write' (what are our color buffer write settings?)\n").c_str()); - READER_ASSERT(value.HasMember("vertex"), (prefix + "Must have string value 'vertex' (what is our vertex shader?)\n").c_str()); - READER_ASSERT(value["vertex"].IsString(), (prefix + "Value 'vertex' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("fragment") || value.HasMember("pixel"), (prefix + "Must have string value named 'fragment' or 'pixel' (what is our fragment/pixel shader?)\n").c_str()); - READER_ASSERT(!value.HasMember("fragment") || value["fragment"].IsString(), (prefix + "Value 'fragment' must be a string\n").c_str()); - READER_ASSERT(!value.HasMember("pixel") || value["pixel"].IsString(), (prefix + "Value 'pixel' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("uniforms"), (prefix + "Must have array value 'uniforms' (what are our shader's parameters?)\n").c_str()); - READER_ASSERT(value["uniforms"].IsArray(), (prefix + "Value 'uniforms' must be an array\n").c_str()); + if (!READER_CHECK(value.HasMember("depth"), (prefix + "Must have object value 'depth' (what are our Z-buffer settings?)\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("cull"), (prefix + "Must have object value 'cull' (do we cull triangles based on winding?)\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("write"), (prefix + "Must have object value 'write' (what are our color buffer write settings?)\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("vertex"), (prefix + "Must have string value 'vertex' (what is our vertex shader?)\n").c_str())) return false; + if (!READER_CHECK(value["vertex"].IsString(), (prefix + "Value 'vertex' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("fragment") || value.HasMember("pixel"), (prefix + "Must have string value named 'fragment' or 'pixel' (what is our fragment/pixel shader?)\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("fragment") || value["fragment"].IsString(), (prefix + "Value 'fragment' must be a string\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("pixel") || value["pixel"].IsString(), (prefix + "Value 'pixel' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("uniforms"), (prefix + "Must have array value 'uniforms' (what are our shader's parameters?)\n").c_str())) return false; + if (!READER_CHECK(value["uniforms"].IsArray(), (prefix + "Value 'uniforms' must be an array\n").c_str())) return false; + return true; } diff --git a/src/osd/modules/render/bgfx/effectreader.h b/src/osd/modules/render/bgfx/effectreader.h index e135165cd6d..0bc1b334435 100644 --- a/src/osd/modules/render/bgfx/effectreader.h +++ b/src/osd/modules/render/bgfx/effectreader.h @@ -24,7 +24,7 @@ public: static bgfx_effect* read_from_value(const Value& value, std::string prefix, shader_manager& shaders); private: - static void validate_parameters(const Value& value, std::string prefix); + static bool validate_parameters(const Value& value, std::string prefix); }; #endif // __DRAWBGFX_EFFECT_READER__ diff --git a/src/osd/modules/render/bgfx/entryuniformreader.cpp b/src/osd/modules/render/bgfx/entryuniformreader.cpp index 949fc202bc3..c9a11086817 100644 --- a/src/osd/modules/render/bgfx/entryuniformreader.cpp +++ b/src/osd/modules/render/bgfx/entryuniformreader.cpp @@ -17,12 +17,18 @@ bgfx_entry_uniform* entry_uniform_reader::read_from_value(const Value& value, std::string prefix, bgfx_effect* effect, std::map& sliders, std::map& params) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } std::string name = value["uniform"].GetString(); bgfx_uniform* uniform = effect->uniform(name); - READER_ASSERT(uniform != nullptr, (prefix + "Uniform '" + name + " does not appear to exist\n").c_str()); + if (!READER_CHECK(uniform != nullptr, (prefix + "Uniform '" + name + " does not appear to exist\n").c_str())) + { + return nullptr; + } if (value.HasMember("slider")) { @@ -36,12 +42,18 @@ bgfx_entry_uniform* entry_uniform_reader::read_from_value(const Value& value, st { return param_uniform_reader::read_from_value(value, prefix, uniform, params); } + else + { + READER_CHECK(false, (prefix + "Unrecognized uniform type for uniform binding " + name).c_str()); + } + return nullptr; } -void entry_uniform_reader::validate_parameters(const Value& value, std::string prefix) +bool entry_uniform_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("uniform"), (prefix + "Must have string value 'uniform' (what uniform are we mapping?)\n").c_str()); - READER_ASSERT(value["uniform"].IsString(), (prefix + "Value 'effect' must be a string\n").c_str()); + if (!READER_CHECK(value.HasMember("uniform"), (prefix + "Must have string value 'uniform' (what uniform are we mapping?)\n").c_str())) return false; + if (!READER_CHECK(value["uniform"].IsString(), (prefix + "Value 'effect' must be a string\n").c_str())) return false; + return true; } diff --git a/src/osd/modules/render/bgfx/entryuniformreader.h b/src/osd/modules/render/bgfx/entryuniformreader.h index ae831b5a7f3..73c66269a5e 100644 --- a/src/osd/modules/render/bgfx/entryuniformreader.h +++ b/src/osd/modules/render/bgfx/entryuniformreader.h @@ -27,7 +27,7 @@ public: static bgfx_entry_uniform* read_from_value(const Value& value, std::string prefix, bgfx_effect* effect, std::map& sliders, std::map& params); private: - static void validate_parameters(const Value& value, std::string prefix); + static bool validate_parameters(const Value& value, std::string prefix); }; #endif // __DRAWBGFX_ENTRY_UNIFORM_READER__ diff --git a/src/osd/modules/render/bgfx/inputpair.cpp b/src/osd/modules/render/bgfx/inputpair.cpp index 788daf5f109..24a4b101c5c 100644 --- a/src/osd/modules/render/bgfx/inputpair.cpp +++ b/src/osd/modules/render/bgfx/inputpair.cpp @@ -25,8 +25,13 @@ bgfx_input_pair::bgfx_input_pair(int index, std::string sampler, std::string tex { } -void bgfx_input_pair::bind(bgfx_effect *effect, texture_manager& textures) const +void bgfx_input_pair::bind(bgfx_effect *effect, texture_manager& textures, const int32_t screen) const { assert(effect->uniform(m_sampler) != nullptr); - bgfx::setTexture(m_index, effect->uniform(m_sampler)->handle(), textures.handle(m_texture)); + std::string texture = m_texture; + if (m_texture == "previous") + { + texture = m_texture + std::to_string(screen); + } + bgfx::setTexture(m_index, effect->uniform(m_sampler)->handle(), textures.handle(texture)); } diff --git a/src/osd/modules/render/bgfx/inputpair.h b/src/osd/modules/render/bgfx/inputpair.h index 53a249c9693..c4664beb2b9 100644 --- a/src/osd/modules/render/bgfx/inputpair.h +++ b/src/osd/modules/render/bgfx/inputpair.h @@ -24,7 +24,7 @@ class bgfx_input_pair public: bgfx_input_pair(int index, std::string sampler, std::string texture); - void bind(bgfx_effect *effect, texture_manager& textures) const; + void bind(bgfx_effect *effect, texture_manager& textures, const int32_t screen) const; // Getters std::string sampler() const { return m_sampler; } diff --git a/src/osd/modules/render/bgfx/paramreader.cpp b/src/osd/modules/render/bgfx/paramreader.cpp index edccf65b09e..f8225c39457 100644 --- a/src/osd/modules/render/bgfx/paramreader.cpp +++ b/src/osd/modules/render/bgfx/paramreader.cpp @@ -23,7 +23,10 @@ const parameter_reader::string_to_enum parameter_reader::TYPE_NAMES[parameter_re bgfx_parameter* parameter_reader::read_from_value(const Value& value, std::string prefix, uint32_t window_index) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } std::string name = value["name"].GetString(); bgfx_parameter::parameter_type type = bgfx_parameter::parameter_type(get_enum_from_value(value, "type", bgfx_parameter::parameter_type::PARAM_FRAME, TYPE_NAMES, TYPE_COUNT)); @@ -44,18 +47,19 @@ bgfx_parameter* parameter_reader::read_from_value(const Value& value, std::strin } else { - assert(false); + READER_CHECK(false, (prefix + "Unknown parameter type '" + std::string(value["type"].GetString()) + "'\n").c_str()); } return nullptr; } -void parameter_reader::validate_parameters(const Value& value, std::string prefix) +bool parameter_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str()); - READER_ASSERT(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("type"), (prefix + "Must have string value 'type'\n").c_str()); - READER_ASSERT(value["type"].IsString(), (prefix + "Value 'type' must be a string\n").c_str()); - READER_ASSERT(!value.HasMember("period") || value["period"].IsNumber(), (prefix + "Value 'period' must be numeric\n").c_str()); - READER_ASSERT(!value.HasMember("limit") || value["limit"].IsNumber(), (prefix + "Value 'period' must be numeric\n").c_str()); + if (!READER_CHECK(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str())) return false; + if (!READER_CHECK(value["name"].IsString(), (prefix + "Value 'name' must be a string\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\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("period") || value["period"].IsNumber(), (prefix + "Value 'period' must be numeric\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("limit") || value["limit"].IsNumber(), (prefix + "Value 'period' must be numeric\n").c_str())) return false; + return true; } diff --git a/src/osd/modules/render/bgfx/paramreader.h b/src/osd/modules/render/bgfx/paramreader.h index 98f9fa393f0..5b48c08251a 100644 --- a/src/osd/modules/render/bgfx/paramreader.h +++ b/src/osd/modules/render/bgfx/paramreader.h @@ -21,7 +21,7 @@ public: static bgfx_parameter* read_from_value(const Value& value, std::string prefix, uint32_t window_index); private: - static void validate_parameters(const Value& value, std::string prefix); + static bool validate_parameters(const Value& value, std::string prefix); static const int TYPE_COUNT = 3; static const string_to_enum TYPE_NAMES[TYPE_COUNT]; diff --git a/src/osd/modules/render/bgfx/paramuniformreader.cpp b/src/osd/modules/render/bgfx/paramuniformreader.cpp index d6941dd1ccc..704b79b204f 100644 --- a/src/osd/modules/render/bgfx/paramuniformreader.cpp +++ b/src/osd/modules/render/bgfx/paramuniformreader.cpp @@ -14,15 +14,19 @@ bgfx_entry_uniform* param_uniform_reader::read_from_value(const Value& value, std::string prefix, bgfx_uniform* uniform, std::map& params) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } std::string parameter = value["parameter"].GetString(); return new bgfx_param_uniform(uniform, params[parameter]); } -void param_uniform_reader::validate_parameters(const Value& value, std::string prefix) +bool param_uniform_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("parameter"), (prefix + "Must have string value 'parameter' (what parameter is being mapped?)\n").c_str()); - READER_ASSERT(value["parameter"].IsString(), (prefix + "Value 'parameter' must be a string\n").c_str()); + if (!READER_CHECK(value.HasMember("parameter"), (prefix + "Must have string value 'parameter' (what parameter is being mapped?)\n").c_str())) return false; + if (!READER_CHECK(value["parameter"].IsString(), (prefix + "Value 'parameter' must be a string\n").c_str())) return false; + return true; } diff --git a/src/osd/modules/render/bgfx/paramuniformreader.h b/src/osd/modules/render/bgfx/paramuniformreader.h index ee4f72d1df1..baf281b562b 100644 --- a/src/osd/modules/render/bgfx/paramuniformreader.h +++ b/src/osd/modules/render/bgfx/paramuniformreader.h @@ -26,7 +26,7 @@ public: static bgfx_entry_uniform* read_from_value(const Value& value, std::string prefix, bgfx_uniform* uniform, std::map& params); private: - static void validate_parameters(const Value& value, std::string prefix); + static bool validate_parameters(const Value& value, std::string prefix); }; #endif // __DRAWBGFX_PARAM_UNIFORM_READER__ diff --git a/src/osd/modules/render/bgfx/sliderreader.cpp b/src/osd/modules/render/bgfx/sliderreader.cpp index d4d181738d7..fbc9fd253aa 100644 --- a/src/osd/modules/render/bgfx/sliderreader.cpp +++ b/src/osd/modules/render/bgfx/sliderreader.cpp @@ -35,7 +35,12 @@ const slider_reader::string_to_enum slider_reader::SCREEN_NAMES[slider_reader::S std::vector slider_reader::read_from_value(const Value& value, std::string prefix, running_machine& machine, uint32_t window_index) { - validate_parameters(value, prefix); + std::vector sliders; + + if (!validate_parameters(value, prefix)) + { + return sliders; + } std::string name = value["name"].GetString(); int step = value["step"].GetInt(); @@ -48,17 +53,18 @@ std::vector slider_reader::read_from_value(const Value& value, std std::vector strings; if (value.HasMember("strings")) { - READER_ASSERT(value["strings"].IsArray(), (prefix + "Slider '" + name + "': value 'strings' must be an array\n").c_str()); const Value& string_array = value["strings"]; for (UINT32 i = 0; i < string_array.Size(); i++) { - READER_ASSERT(string_array[i].IsString(), (prefix + "Slider '" + name + "': strings[" + std::to_string(i) + "]: must be a string\n").c_str()); + if (!READER_CHECK(string_array[i].IsString(), (prefix + "Slider '" + name + "': strings[" + std::to_string(i) + "]: must be a string\n").c_str())) + { + return sliders; + } strings.push_back(std::string(string_array[i].GetString())); } } int slider_count; - std::vector sliders; switch (type) { case bgfx_slider::slider_type::SLIDER_FLOAT: @@ -82,9 +88,9 @@ std::vector slider_reader::read_from_value(const Value& value, std int min[3]; int defaults[3]; int max[3]; - READER_ASSERT(value["min"].IsArray(), (prefix + "Slider '" + name + "': value 'min' must be an array\n").c_str()); - READER_ASSERT(value["default"].IsArray(), (prefix + "Slider '" + name + "': value 'default' must be an array\n").c_str()); - READER_ASSERT(value["max"].IsArray(), (prefix + "Slider '" + name + "': value 'max' must be an array\n").c_str()); + if (!READER_CHECK(value["min"].IsArray(), (prefix + "Slider '" + name + "': value 'min' must be an array\n").c_str())) return sliders; + if (!READER_CHECK(value["default"].IsArray(), (prefix + "Slider '" + name + "': value 'default' must be an array\n").c_str())) return sliders; + if (!READER_CHECK(value["max"].IsArray(), (prefix + "Slider '" + name + "': value 'max' must be an array\n").c_str())) return sliders; get_values(value, prefix + "Slider '" + name + "': 'min': ", "min", min, slider_count); get_values(value, prefix + "Slider '" + name + "': 'default': ", "default", defaults, slider_count); get_values(value, prefix + "Slider '" + name + "': 'max': ", "max", max, slider_count); @@ -120,37 +126,40 @@ std::vector slider_reader::read_from_value(const Value& value, std return sliders; } -void slider_reader::get_values(const Value& value, std::string prefix, std::string name, int* values, const int count) +bool slider_reader::get_values(const Value& value, std::string prefix, std::string name, int* values, const int count) { const char* name_str = name.c_str(); const Value& value_array = value[name_str]; for (UINT32 i = 0; i < value_array.Size() && i < count; i++) { - READER_ASSERT(value_array[i].IsInt(), (prefix + "Entry " + std::to_string(i) + " must be an integer\n").c_str()); + if (!READER_CHECK(value_array[i].IsInt(), (prefix + "Entry " + std::to_string(i) + " must be an integer\n").c_str())) return false; values[i] = value_array[i].GetInt(); } + return true; } -void slider_reader::validate_parameters(const Value& value, std::string prefix) +bool slider_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str()); - READER_ASSERT(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("min"), (prefix + "Must have integer or array value 'min'\n").c_str()); - READER_ASSERT(value["min"].IsInt() || value["min"].IsArray(), (prefix + "Value 'min' must be an integer or an array the size of the corresponding slider type\n").c_str()); - READER_ASSERT(value.HasMember("default"), (prefix + "Must have integer or array value 'default'\n").c_str()); - READER_ASSERT(value["default"].IsInt() || value["default"].IsArray(), (prefix + "Value 'default' must be an integer or an array the size of the corresponding slider type\n").c_str()); - READER_ASSERT(value.HasMember("max"), (prefix + "Must have integer or array value 'max'\n").c_str()); - READER_ASSERT(value["max"].IsInt() || value["max"].IsArray(), (prefix + "Value 'max' must be an integer or an array the size of the corresponding slider type\n").c_str()); - READER_ASSERT(value.HasMember("step"), (prefix + "Must have integer value 'step'\n").c_str()); - READER_ASSERT(value["step"].IsInt(), (prefix + "Value 'step' must be an integer (how much does this slider increment by internally?)\n").c_str()); - READER_ASSERT(value.HasMember("type"), (prefix + "Must have string value 'type'\n").c_str()); - READER_ASSERT(value["type"].IsString(), (prefix + "Value 'type' must be a string (what type of slider is this? [int_enum, int, float])\n").c_str()); - READER_ASSERT(value.HasMember("screen"), (prefix + "Must have string value 'screen'\n").c_str()); - READER_ASSERT(value["screen"].IsString(), (prefix + "Value 'screen' must be a string (what type of output device does this slider apply to? [none, raster, vector, crt, lcd, non_vector, any])\n").c_str()); - READER_ASSERT(value.HasMember("scale"), (prefix + "Must have numeric value 'scale'\n").c_str()); - READER_ASSERT(value["scale"].IsNumber(), (prefix + "Value 'scale' must be a number (what do we multiply with to get 1.0?)").c_str()); - READER_ASSERT(value.HasMember("format"), (prefix + "Must have string value 'format'\n").c_str()); - READER_ASSERT(value["format"].IsString(), (prefix + "Value 'scale' must be a string (how would we display it in a printf?)").c_str()); - READER_ASSERT(value.HasMember("text"), (prefix + "Must have string value 'text'\n").c_str()); - READER_ASSERT(value["text"].IsString(), (prefix + "Value 'text' must be a string (how would you explain it?)").c_str()); + if (!READER_CHECK(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str())) return false; + 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 integer or array value 'min'\n").c_str())) return false; + if (!READER_CHECK(value["min"].IsInt() || value["min"].IsArray(), (prefix + "Value 'min' must be an integer or an array the size of the corresponding slider type\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("default"), (prefix + "Must have integer or array value 'default'\n").c_str())) return false; + if (!READER_CHECK(value["default"].IsInt() || value["default"].IsArray(), (prefix + "Value 'default' must be an integer or an array the size of the corresponding slider type\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("max"), (prefix + "Must have integer or array value 'max'\n").c_str())) return false; + if (!READER_CHECK(value["max"].IsInt() || value["max"].IsArray(), (prefix + "Value 'max' must be an integer or an array the size of the corresponding slider type\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("step"), (prefix + "Must have integer value 'step'\n").c_str())) return false; + if (!READER_CHECK(value["step"].IsInt(), (prefix + "Value 'step' must be an integer (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; + if (!READER_CHECK(value.HasMember("screen"), (prefix + "Must have string value 'screen'\n").c_str())) return false; + if (!READER_CHECK(value["screen"].IsString(), (prefix + "Value 'screen' must be a string (what type of output device does this slider apply to? [none, raster, vector, crt, lcd, non_vector, any])\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("scale"), (prefix + "Must have numeric value 'scale'\n").c_str())) return false; + if (!READER_CHECK(value["scale"].IsNumber(), (prefix + "Value 'scale' must be a number (what do we multiply with to get 1.0?)").c_str())) return false; + if (!READER_CHECK(value.HasMember("format"), (prefix + "Must have string value 'format'\n").c_str())) return false; + if (!READER_CHECK(value["format"].IsString(), (prefix + "Value 'scale' must be a string (how would we display it in a printf?)").c_str())) return false; + if (!READER_CHECK(value.HasMember("text"), (prefix + "Must have string value 'text'\n").c_str())) return false; + if (!READER_CHECK(value["text"].IsString(), (prefix + "Value 'text' must be a string (how would you explain it?)").c_str())) return false; + if (!READER_CHECK(!value.HasMember("strings") || value["strings"].IsArray(), (prefix + "Value 'strings' must be an array\n").c_str())) return false; + return true; } diff --git a/src/osd/modules/render/bgfx/sliderreader.h b/src/osd/modules/render/bgfx/sliderreader.h index 8db5c4ac4d1..f6e42694fa9 100644 --- a/src/osd/modules/render/bgfx/sliderreader.h +++ b/src/osd/modules/render/bgfx/sliderreader.h @@ -24,8 +24,8 @@ public: static std::vector read_from_value(const Value& value, std::string prefix, running_machine& machine, uint32_t window_index); private: - static void get_values(const Value& value, std::string prefix, std::string name, int* values, const int count); - static void validate_parameters(const Value& value, std::string prefix); + static bool get_values(const Value& value, std::string prefix, std::string name, int* values, const int count); + static bool validate_parameters(const Value& value, std::string prefix); static const int TYPE_COUNT = 5; static const string_to_enum TYPE_NAMES[TYPE_COUNT]; diff --git a/src/osd/modules/render/bgfx/slideruniformreader.cpp b/src/osd/modules/render/bgfx/slideruniformreader.cpp index c30e3831d51..95de126adf9 100644 --- a/src/osd/modules/render/bgfx/slideruniformreader.cpp +++ b/src/osd/modules/render/bgfx/slideruniformreader.cpp @@ -16,7 +16,10 @@ bgfx_entry_uniform* slider_uniform_reader::read_from_value(const Value& value, std::string prefix, bgfx_uniform* uniform, std::map& sliders) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } std::string name = value["slider"].GetString(); std::vector slider_list; @@ -35,8 +38,9 @@ bgfx_entry_uniform* slider_uniform_reader::read_from_value(const Value& value, s return new bgfx_slider_uniform(uniform, slider_list); } -void slider_uniform_reader::validate_parameters(const Value& value, std::string prefix) +bool slider_uniform_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("slider"), (prefix + "Must have string value 'slider' (what slider are we getting the value of?)\n").c_str()); - READER_ASSERT(value["slider"].IsString(), (prefix + "Value 'slider' must be a string\n").c_str()); + if (!READER_CHECK(value.HasMember("slider"), (prefix + "Must have string value 'slider' (what slider are we getting the value of?)\n").c_str())) return false; + if (!READER_CHECK(value["slider"].IsString(), (prefix + "Value 'slider' must be a string\n").c_str())) return false; + return true; } diff --git a/src/osd/modules/render/bgfx/slideruniformreader.h b/src/osd/modules/render/bgfx/slideruniformreader.h index f19c715fdea..0db387270b0 100644 --- a/src/osd/modules/render/bgfx/slideruniformreader.h +++ b/src/osd/modules/render/bgfx/slideruniformreader.h @@ -26,7 +26,7 @@ public: static bgfx_entry_uniform* read_from_value(const Value& value, std::string prefix, bgfx_uniform* uniform, std::map& sliders); private: - static void validate_parameters(const Value& value, std::string prefix); + static bool validate_parameters(const Value& value, std::string prefix); }; #endif // __DRAWBGFX_SLIDER_UNIFORM_READER__ diff --git a/src/osd/modules/render/bgfx/statereader.h b/src/osd/modules/render/bgfx/statereader.h index b16844352c3..5b9a5f5625d 100644 --- a/src/osd/modules/render/bgfx/statereader.h +++ b/src/osd/modules/render/bgfx/statereader.h @@ -36,7 +36,7 @@ protected: static uint64_t get_param_from_string(std::string value, const string_to_enum* enums, const int count); protected: - static void READER_ASSERT(bool condition, const char* format, ...) + static bool READER_CHECK(bool condition, const char* format, ...) { if (!condition) { @@ -44,10 +44,10 @@ protected: va_start(ap, format); char buf[2048]; vsnprintf(buf, 2048, format, ap); - printf("%s\n", buf); - fflush(stdout); - fatalerror("%s", buf); + osd_printf_error("Error: %s\n", buf); + va_end(ap); } + return condition; } private: diff --git a/src/osd/modules/render/bgfx/suppressorreader.cpp b/src/osd/modules/render/bgfx/suppressorreader.cpp index ad17855c0fa..6d736a5a411 100644 --- a/src/osd/modules/render/bgfx/suppressorreader.cpp +++ b/src/osd/modules/render/bgfx/suppressorreader.cpp @@ -25,7 +25,10 @@ const suppressor_reader::string_to_enum suppressor_reader::COMBINE_NAMES[suppres bgfx_suppressor* suppressor_reader::read_from_value(const Value& value, std::string prefix, std::map& sliders) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } std::string name = value["name"].GetString(); uint32_t condition = uint32_t(get_enum_from_value(value, "condition", bgfx_suppressor::condition_type::CONDITION_EQUAL, CONDITION_NAMES, CONDITION_COUNT)); @@ -57,6 +60,7 @@ bgfx_suppressor* suppressor_reader::read_from_value(const Value& value, std::str if (slider_count > 1) { get_values(value, prefix, "value", values, slider_count); + if (!READER_CHECK(slider_count == value["value"].GetArray().Size(), (prefix + "Expected " + std::to_string(slider_count) + " values, got " + std::to_string(value["value"].GetArray().Size()) + "\n").c_str())) return nullptr; for (int index = 1; index < slider_count; index++) { check_sliders.push_back(sliders[name + std::to_string(index)]); @@ -70,21 +74,23 @@ bgfx_suppressor* suppressor_reader::read_from_value(const Value& value, std::str return new bgfx_suppressor(check_sliders, condition, mode, values); } -void suppressor_reader::validate_parameters(const Value& value, std::string prefix) +bool suppressor_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str()); - READER_ASSERT(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str()); - READER_ASSERT(value.HasMember("value"), (prefix + "Must have numeric or array value 'value'\n").c_str()); - READER_ASSERT(value["value"].IsNumber() || value["value"].IsArray(), (prefix + "Value 'value' must be a number or array the size of the corresponding slider type\n").c_str()); + if (!READER_CHECK(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str())) return false; + if (!READER_CHECK(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("value"), (prefix + "Must have numeric or array value 'value'\n").c_str())) return false; + if (!READER_CHECK(value["value"].IsNumber() || value["value"].IsArray(), (prefix + "Value 'value' must be a number or array the size of the corresponding slider type\n").c_str())) return false; + return true; } -void suppressor_reader::get_values(const Value& value, std::string prefix, std::string name, int* values, const int count) +bool suppressor_reader::get_values(const Value& value, std::string prefix, std::string name, int* values, const int count) { const char* name_str = name.c_str(); const Value& value_array = value[name_str]; for (UINT32 i = 0; i < value_array.Size() && i < count; i++) { - READER_ASSERT(value_array[i].IsInt(), (prefix + "value[" + std::to_string(i) + "] must be an integer\n").c_str()); + if (!READER_CHECK(value_array[i].IsInt(), (prefix + "value[" + std::to_string(i) + "] must be an integer\n").c_str())) return false; values[i] = value_array[i].GetInt(); } + return true; } diff --git a/src/osd/modules/render/bgfx/suppressorreader.h b/src/osd/modules/render/bgfx/suppressorreader.h index c69b45dc83b..fc0a3f1cb8b 100644 --- a/src/osd/modules/render/bgfx/suppressorreader.h +++ b/src/osd/modules/render/bgfx/suppressorreader.h @@ -25,9 +25,8 @@ public: static bgfx_suppressor* read_from_value(const Value& value, std::string prefix, std::map& sliders); private: - static void get_values(const Value& value, std::string prefix, std::string name, int* values, const int count); - - static void validate_parameters(const Value& value, std::string prefix); + static bool get_values(const Value& value, std::string prefix, std::string name, int* values, const int count); + static bool validate_parameters(const Value& value, std::string prefix); static const int CONDITION_COUNT = 2; static const string_to_enum CONDITION_NAMES[CONDITION_COUNT]; diff --git a/src/osd/modules/render/bgfx/target.cpp b/src/osd/modules/render/bgfx/target.cpp index 4b651d3d12c..e29cbc810d9 100644 --- a/src/osd/modules/render/bgfx/target.cpp +++ b/src/osd/modules/render/bgfx/target.cpp @@ -8,7 +8,7 @@ #include "target.h" -bgfx_target::bgfx_target(std::string name, bgfx::TextureFormat::Enum format, uint16_t width, uint16_t height, uint32_t prescale_x, uint32_t prescale_y, uint32_t style, bool double_buffer, bool filter, bool init) +bgfx_target::bgfx_target(std::string name, bgfx::TextureFormat::Enum format, uint16_t width, uint16_t height, uint32_t prescale_x, uint32_t prescale_y, uint32_t style, bool double_buffer, bool filter, bool init, bool output) : m_name(name) , m_format(format) , m_targets(nullptr) @@ -20,6 +20,7 @@ bgfx_target::bgfx_target(std::string name, bgfx::TextureFormat::Enum format, uin , m_double_buffer(double_buffer) , m_style(style) , m_filter(filter) + , m_output(output) , m_current_page(0) , m_initialized(false) , m_page_count(double_buffer ? 2 : 1) diff --git a/src/osd/modules/render/bgfx/target.h b/src/osd/modules/render/bgfx/target.h index 9d0481a0c7f..ad8efbde2cb 100644 --- a/src/osd/modules/render/bgfx/target.h +++ b/src/osd/modules/render/bgfx/target.h @@ -27,7 +27,7 @@ enum class bgfx_target : public bgfx_texture_handle_provider { public: - bgfx_target(std::string name, bgfx::TextureFormat::Enum format, uint16_t width, uint16_t height, uint32_t prescale_x, uint32_t prescale_y, uint32_t style, bool double_buffer, bool filter, bool init = true); + bgfx_target(std::string name, bgfx::TextureFormat::Enum format, uint16_t width, uint16_t height, uint32_t prescale_x, uint32_t prescale_y, uint32_t style, bool double_buffer, bool filter, bool init = true, bool output = false); bgfx_target(void *handle, uint16_t width, uint16_t height); virtual ~bgfx_target(); @@ -42,6 +42,7 @@ public: bool filter() const { return m_filter; } uint32_t prescale_x() const { return m_prescale_x; } uint32_t prescale_y() const { return m_prescale_y; } + bool output() const { return m_output; } // bgfx_texture_handle_provider virtual uint16_t width() const override { return m_width; } @@ -65,6 +66,7 @@ private: bool m_double_buffer; uint32_t m_style; bool m_filter; + bool m_output; uint32_t m_current_page; diff --git a/src/osd/modules/render/bgfx/targetmanager.cpp b/src/osd/modules/render/bgfx/targetmanager.cpp index d726d8592b3..3e5828efabc 100644 --- a/src/osd/modules/render/bgfx/targetmanager.cpp +++ b/src/osd/modules/render/bgfx/targetmanager.cpp @@ -13,7 +13,10 @@ #include +#include "modules/lib/osdobj_common.h" + #include "targetmanager.h" + #include "target.h" target_manager::~target_manager() @@ -25,9 +28,9 @@ target_manager::~target_manager() m_targets.clear(); } -bgfx_target* target_manager::create_target(std::string name, bgfx::TextureFormat::Enum format, uint32_t width, uint32_t height, uint32_t prescale_x, uint32_t prescale_y, uint32_t style, bool double_buffer, bool filter) +bgfx_target* target_manager::create_target(std::string name, bgfx::TextureFormat::Enum format, uint32_t width, uint32_t height, uint32_t prescale_x, uint32_t prescale_y, uint32_t style, bool double_buffer, bool filter, bool output) { - bgfx_target* target = new bgfx_target(name, format, width, height, prescale_x, prescale_y, style, double_buffer, filter, width > 0 && height > 0); + bgfx_target* target = new bgfx_target(name, format, width, height, prescale_x, prescale_y, style, double_buffer, filter, width > 0 && height > 0, output); m_targets[name] = target; m_textures.add_provider(name, target); @@ -78,8 +81,36 @@ void target_manager::update_guest_targets(uint16_t width, uint16_t height) const uint32_t prescale_y = target->prescale_y(); delete target; - m_targets[name] = new bgfx_target(name, format, width, height, prescale_x, prescale_y, TARGET_STYLE_GUEST, double_buffered, filter); + m_targets[name] = new bgfx_target(name, format, m_guest_width, m_guest_height, prescale_x, prescale_y, TARGET_STYLE_GUEST, double_buffered, filter); m_textures.add_provider(name, m_targets[name]); } } } + +void target_manager::update_window_count(uint32_t count) +{ + if (count != m_window_count) + { + m_window_count = count; + rebuild_outputs(); + } +} + +void target_manager::rebuild_outputs() +{ + for (uint32_t i = 0; i < m_window_count; i++) + { + rebuild_target("output" + std::to_string(i)); + rebuild_target("previous" + std::to_string(i)); + } +} + +void target_manager::rebuild_target(std::string name) +{ + bgfx_target* target = m_targets[name]; + if (target != nullptr) { + delete target; + } + m_targets[name] = new bgfx_target(name, bgfx::TextureFormat::RGBA8, m_guest_width, m_guest_height, m_options.bgfx_prescale_x(), m_options.bgfx_prescale_y(), TARGET_STYLE_GUEST, true, true); + m_textures.add_provider(name, m_targets[name]); +} \ No newline at end of file diff --git a/src/osd/modules/render/bgfx/targetmanager.h b/src/osd/modules/render/bgfx/targetmanager.h index 3d892f921ed..f017119502c 100644 --- a/src/osd/modules/render/bgfx/targetmanager.h +++ b/src/osd/modules/render/bgfx/targetmanager.h @@ -22,16 +22,18 @@ #include "texturemanager.h" class bgfx_target; +class osd_options; class target_manager { public: - target_manager(texture_manager& textures) : m_textures(textures), m_guest_width(0), m_guest_height(0) { } + target_manager(osd_options& options, texture_manager& textures) : m_textures(textures), m_options(options), m_guest_width(0), m_guest_height(0), m_window_count(0) { } ~target_manager(); - bgfx_target* create_target(std::string name, bgfx::TextureFormat::Enum format, uint32_t width, uint32_t height, uint32_t prescale_x, uint32_t prescale_y, uint32_t style, bool double_buffer, bool filter); + bgfx_target* create_target(std::string name, bgfx::TextureFormat::Enum format, uint32_t width, uint32_t height, uint32_t prescale_x, uint32_t prescale_y, uint32_t style, bool double_buffer, bool filter, bool output); bgfx_target* create_backbuffer(void *handle, uint32_t width, uint32_t height); void update_guest_targets(uint16_t width, uint16_t height); + void update_window_count(uint32_t count); // Getters bgfx_target* target(std::string name); @@ -39,11 +41,16 @@ public: uint16_t guest_height() const { return m_guest_height; } private: + void rebuild_outputs(); + void rebuild_target(std::string name); + std::map m_targets; texture_manager& m_textures; + osd_options& m_options; uint16_t m_guest_width; uint16_t m_guest_height; + uint32_t m_window_count; }; #endif // __DRAWBGFX_TARGET_MANAGER__ diff --git a/src/osd/modules/render/bgfx/targetreader.cpp b/src/osd/modules/render/bgfx/targetreader.cpp new file mode 100644 index 00000000000..1f375155751 --- /dev/null +++ b/src/osd/modules/render/bgfx/targetreader.cpp @@ -0,0 +1,87 @@ +// license:BSD-3-Clause +// copyright-holders:Ryan Holtz +//============================================================ +// +// targetreader.cpp - BGFX target JSON reader +// +//============================================================ + +#include + +#include "emu.h" +#include + +#include "targetreader.h" +#include "targetmanager.h" +#include "target.h" + +const target_reader::string_to_enum target_reader::STYLE_NAMES[target_reader::STYLE_COUNT] = { + { "guest", TARGET_STYLE_GUEST }, + { "native", TARGET_STYLE_NATIVE }, + { "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_width, uint32_t screen_height) +{ + if (!validate_parameters(value, prefix)) + { + return false; + } + + std::string target_name = value["name"].GetString(); + uint32_t mode = uint32_t(get_enum_from_value(value, "mode", TARGET_STYLE_NATIVE, STYLE_NAMES, STYLE_COUNT)); + bool bilinear = get_bool(value, "bilinear", true); + bool double_buffer = get_bool(value, "doublebuffer", true); + bool prescale = get_bool(value, "prescale", false); + bool output = get_bool(value, "output", false); + + uint16_t width = 0; + uint16_t height = 0; + switch (mode) + { + case TARGET_STYLE_GUEST: + width = targets.guest_width(); + height = targets.guest_height(); + break; + case TARGET_STYLE_NATIVE: + width = screen_width; + height = screen_height; + 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; + width = uint32_t(value["width"].GetDouble()); + height = uint32_t(value["height"].GetDouble()); + break; + } + + uint32_t prescale_x = 1; + uint32_t prescale_y = 1; + if (prescale) + { + prescale_x = options.bgfx_prescale_x(); + prescale_y = options.bgfx_prescale_y(); + } + + if (!output) + { + targets.create_target(target_name, bgfx::TextureFormat::RGBA8, width, height, prescale_x, prescale_y, mode, double_buffer, bilinear, output); + } + + return true; +} + +bool target_reader::validate_parameters(const Value& value, std::string prefix) +{ + if (!READER_CHECK(value.HasMember("name"), (prefix + "Must have string value 'name'\n").c_str())) return false; + if (!READER_CHECK(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("mode"), (prefix + "Must have string enum 'mode'\n").c_str())) return false; + if (!READER_CHECK(value["mode"].IsString(), (prefix + "Value 'mode' must be a string (what screens does this apply to?)\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("bilinear") || value["bilinear"].IsBool(), (prefix + "Value 'bilinear' must be a boolean\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("doublebuffer") || value["doublebuffer"].IsBool(), (prefix + "Value 'doublebuffer' must be a boolean\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("prescale") || value["prescale"].IsBool(), (prefix + "Value 'prescale' must be a boolean\n").c_str())) return false; + if (!READER_CHECK(!value.HasMember("output") || value["output"].IsBool(), (prefix + "Value 'output' must be a boolean\n").c_str())) return false; + return true; +} diff --git a/src/osd/modules/render/bgfx/targetreader.h b/src/osd/modules/render/bgfx/targetreader.h new file mode 100644 index 00000000000..13709905cfb --- /dev/null +++ b/src/osd/modules/render/bgfx/targetreader.h @@ -0,0 +1,33 @@ +// license:BSD-3-Clause +// copyright-holders:Ryan Holtz +//============================================================ +// +// targetreader.h - BGFX target JSON reader +// +//============================================================ + +#pragma once + +#ifndef __DRAWBGFX_TARGET_READER__ +#define __DRAWBGFX_TARGET_READER__ + +#include + +#include "statereader.h" + +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_width, uint32_t screen_height); + +private: + static bool validate_parameters(const Value& value, std::string prefix); + + static const int STYLE_COUNT = 3; + static const string_to_enum STYLE_NAMES[STYLE_COUNT]; +}; + +#endif // __DRAWBGFX_TARGET_READER__ diff --git a/src/osd/modules/render/bgfx/uniformreader.cpp b/src/osd/modules/render/bgfx/uniformreader.cpp index 8c60113d364..cfbcf0bdac0 100644 --- a/src/osd/modules/render/bgfx/uniformreader.cpp +++ b/src/osd/modules/render/bgfx/uniformreader.cpp @@ -7,28 +7,27 @@ //============================================================ #include "uniformreader.h" + #include "uniform.h" const uniform_reader::string_to_enum uniform_reader::TYPE_NAMES[uniform_reader::TYPE_COUNT] = { { "int", bgfx::UniformType::Int1 }, { "vec4", bgfx::UniformType::Vec4 }, { "mat3", bgfx::UniformType::Mat3 }, - { "mat4", bgfx::UniformType::Mat4 }, - { "camera", bgfx::UniformType::Mat4 } + { "mat4", bgfx::UniformType::Mat4 } }; -bgfx_uniform* uniform_reader::read_from_value(const Value& value) +bgfx_uniform* uniform_reader::read_from_value(const Value& value, std::string prefix) { - assert(value.HasMember("name")); - assert(value["name"].IsString()); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } const char* name = value["name"].GetString(); - assert(value.HasMember("type")); bgfx::UniformType::Enum type = bgfx::UniformType::Enum(get_enum_from_value(value, "type", bgfx::UniformType::Vec4, TYPE_NAMES, TYPE_COUNT)); const size_t type_size = bgfx_uniform::get_size_for_type(type); - assert(value.HasMember("values")); - assert(value["values"].IsArray()); const Value& value_array = value["values"]; const size_t array_size = value_array.Size() * sizeof(float); @@ -52,3 +51,13 @@ bgfx_uniform* uniform_reader::read_from_value(const Value& value) return uniform; } + +bool uniform_reader::validate_parameters(const Value& value, std::string prefix) +{ + if (!READER_CHECK(value.HasMember("name"), (prefix + "Must have string value 'name' (what is this uniform called in the shader code?)\n").c_str())) return false; + if (!READER_CHECK(value["name"].IsString(), (prefix + "Value 'name' must be a string\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("type"), (prefix + "Must have string value 'type' [int, vec4, mat3, mat4]\n").c_str())) return false; + if (!READER_CHECK(value.HasMember("values"), (prefix + "Must have array value 'values' (what are the uniform's default values?)\n").c_str())) return false; + if (!READER_CHECK(value["values"].IsArray(), (prefix + "Value 'values' must be an array\n").c_str())) return false; + return true; +} diff --git a/src/osd/modules/render/bgfx/uniformreader.h b/src/osd/modules/render/bgfx/uniformreader.h index 40bedf8b732..056feee04ba 100644 --- a/src/osd/modules/render/bgfx/uniformreader.h +++ b/src/osd/modules/render/bgfx/uniformreader.h @@ -17,24 +17,15 @@ class bgfx_uniform; -enum uniform_type -{ - TYPE_INT1 = bgfx::UniformType::Int1, - TYPE_VEC4 = bgfx::UniformType::Vec4, - TYPE_MAT3 = bgfx::UniformType::Mat3, - TYPE_MAT4 = bgfx::UniformType::Mat4, - TYPE_CAMERA, // Alias for the current ortho camera, used to auto-bind on material load - - TYPE_COUNT = 5 -}; - class uniform_reader : public state_reader { public: - static bgfx_uniform* read_from_value(const Value& value); + static bgfx_uniform* read_from_value(const Value& value, std::string prefix); private: - static const int TYPE_COUNT = uniform_type::TYPE_COUNT; + static bool validate_parameters(const Value& value, std::string prefix); + + static const int TYPE_COUNT = 4; static const string_to_enum TYPE_NAMES[TYPE_COUNT]; }; diff --git a/src/osd/modules/render/bgfx/valueuniformreader.cpp b/src/osd/modules/render/bgfx/valueuniformreader.cpp index a5cdb35e132..bbd9a886bf9 100644 --- a/src/osd/modules/render/bgfx/valueuniformreader.cpp +++ b/src/osd/modules/render/bgfx/valueuniformreader.cpp @@ -13,7 +13,10 @@ bgfx_entry_uniform* value_uniform_reader::read_from_value(const Value& value, std::string prefix, bgfx_uniform* uniform) { - validate_parameters(value, prefix); + if (!validate_parameters(value, prefix)) + { + return nullptr; + } float values[4]; int count = 1; @@ -33,8 +36,9 @@ bgfx_entry_uniform* value_uniform_reader::read_from_value(const Value& value, st return new bgfx_value_uniform(uniform, values, count); } -void value_uniform_reader::validate_parameters(const Value& value, std::string prefix) +bool value_uniform_reader::validate_parameters(const Value& value, std::string prefix) { - READER_ASSERT(value.HasMember("value"), (prefix + "Must have string value 'value' (what value is being assigned?)\n").c_str()); - READER_ASSERT(value["value"].IsArray() || value["value"].IsNumber(), (prefix + "Value 'value' must be numeric or an array\n").c_str()); + if (!READER_CHECK(value.HasMember("value"), (prefix + "Must have string value 'value' (what value is being assigned?)\n").c_str())) return false; + if (!READER_CHECK(value["value"].IsArray() || value["value"].IsNumber(), (prefix + "Value 'value' must be numeric or an array\n").c_str())) return false; + return true; } diff --git a/src/osd/modules/render/bgfx/valueuniformreader.h b/src/osd/modules/render/bgfx/valueuniformreader.h index ffba213fb26..0b6fead1cca 100644 --- a/src/osd/modules/render/bgfx/valueuniformreader.h +++ b/src/osd/modules/render/bgfx/valueuniformreader.h @@ -25,7 +25,7 @@ public: static bgfx_entry_uniform* read_from_value(const Value& value, std::string prefix, bgfx_uniform* uniform); private: - static void validate_parameters(const Value& value, std::string prefix); + static bool validate_parameters(const Value& value, std::string prefix); }; #endif // __DRAWBGFX_VALUE_UNIFORM_READER__ diff --git a/src/osd/modules/render/drawbgfx.cpp b/src/osd/modules/render/drawbgfx.cpp index a6bb3b436e2..d60bd915d1a 100644 --- a/src/osd/modules/render/drawbgfx.cpp +++ b/src/osd/modules/render/drawbgfx.cpp @@ -65,11 +65,6 @@ const char* renderer_bgfx::WINDOW_PREFIX = "Window 0, "; #define GIBBERISH (0) -//============================================================ -// INLINES -//============================================================ - - //============================================================ // TYPES //============================================================ @@ -168,7 +163,7 @@ int renderer_bgfx::create() } m_textures = new texture_manager(); - m_targets = new target_manager(*m_textures); + m_targets = new target_manager(options, *m_textures); m_shaders = new shader_manager(options); m_effects = new effect_manager(options, *m_shaders); @@ -353,14 +348,22 @@ void renderer_bgfx::process_screen_quad(int view, render_primitive* prim) bgfx_texture *texture = new bgfx_texture("screen", bgfx::TextureFormat::RGBA8, tex_width, tex_height, mem); m_textures->add_provider("screen", texture); + int screens = 0; + screen_device_iterator iter(window().machine().root_device()); + for (const screen_device *screen = iter.first(); screen != nullptr; screen = iter.next()) + { + screens++; + } m_targets->update_guest_targets(tex_width, tex_height); - m_screen_chain->process(prim, view, *m_textures, window(), get_blend_state(PRIMFLAG_GET_BLENDMODE(prim->flags))); + m_targets->update_window_count(screens); + + m_screen_chain->process(prim, view, view / m_screen_chain->applicable_passes(), *m_textures, window(), get_blend_state(PRIMFLAG_GET_BLENDMODE(prim->flags))); m_textures->add_provider("screen", nullptr); delete texture; } -void renderer_bgfx::render_post_screen_quad(int view, render_primitive* prim, bgfx::TransientVertexBuffer* buffer) +void renderer_bgfx::render_post_screen_quad(int view, render_primitive* prim, bgfx::TransientVertexBuffer* buffer, int32_t screen) { ScreenVertex* vertex = reinterpret_cast(buffer->data); @@ -369,13 +372,13 @@ void renderer_bgfx::render_post_screen_quad(int view, render_primitive* prim, bg float u[4] = { prim->texcoords.tl.u, prim->texcoords.tr.u, prim->texcoords.bl.u, prim->texcoords.br.u }; float v[4] = { prim->texcoords.tl.v, prim->texcoords.tr.v, prim->texcoords.bl.v, prim->texcoords.br.v }; - if (PRIMFLAG_GET_TEXORIENT(prim->flags) & ORIENTATION_SWAP_XY) + if (false)//PRIMFLAG_GET_TEXORIENT(prim->flags) & ORIENTATION_SWAP_XY) { std::swap(u[1], u[2]); std::swap(v[1], v[2]); } - if (PRIMFLAG_GET_TEXORIENT(prim->flags) & ORIENTATION_FLIP_X) + if (false)//PRIMFLAG_GET_TEXORIENT(prim->flags) & ORIENTATION_FLIP_X) { std::swap(u[0], u[1]); std::swap(v[0], v[1]); @@ -383,7 +386,7 @@ void renderer_bgfx::render_post_screen_quad(int view, render_primitive* prim, bg std::swap(v[2], v[3]); } - if (PRIMFLAG_GET_TEXORIENT(prim->flags) & ORIENTATION_FLIP_Y) + if (false)//PRIMFLAG_GET_TEXORIENT(prim->flags) & ORIENTATION_FLIP_Y) { std::swap(u[0], u[2]); std::swap(v[0], v[2]); @@ -435,7 +438,7 @@ void renderer_bgfx::render_post_screen_quad(int view, render_primitive* prim, bg UINT32 blend = PRIMFLAG_GET_BLENDMODE(prim->flags); bgfx::setVertexBuffer(buffer); - bgfx::setTexture(0, m_screen_effect[blend]->uniform("s_tex")->handle(), m_targets->target(m_screen_chain->output())->texture()); + bgfx::setTexture(0, m_screen_effect[blend]->uniform("s_tex")->handle(), m_targets->target("output" + std::to_string(screen))->texture()); m_screen_effect[blend]->submit(view); } @@ -731,47 +734,52 @@ const bgfx::Memory* renderer_bgfx::mame_texture_data_to_bgfx_texture_data(UINT32 int renderer_bgfx::handle_screen_chains() { - window().m_primlist->acquire_lock(); + if (!m_screen_chain) + { + return 0; + } - int view = 0; + window().m_primlist->acquire_lock(); // process render_primitive *prim = window().m_primlist->first(); + + int seen = 0; while (prim != nullptr) { if (PRIMFLAG_GET_SCREENTEX(prim->flags)) { - process_screen_quad(view, prim); - const int applicable_passes = m_screen_chain->applicable_passes(); - bgfx::setViewFrameBuffer(applicable_passes, BGFX_INVALID_HANDLE); - window().m_primlist->release_lock(); - return applicable_passes * (window().m_index + 1); + process_screen_quad(m_screen_chain->applicable_passes() * seen, prim); + seen++; } prim = prim->next(); } window().m_primlist->release_lock(); - return 0; + uint32_t total_passes = seen * m_screen_chain->applicable_passes(); + bgfx::setViewFrameBuffer(total_passes, BGFX_INVALID_HANDLE); + + return total_passes; } int renderer_bgfx::draw(int update) { + int window_index = window().m_index; int post_view_index = handle_screen_chains(); - int window_index = window().m_index; int view_index = window_index; int first_view_index = 0; - if (post_view_index > 0) + if (m_screen_chain && post_view_index > 0) { - view_index = post_view_index; - first_view_index = m_screen_chain->applicable_passes(); + view_index += post_view_index; + first_view_index = post_view_index; } // Set view 0 default viewport. osd_dim wdim = window().get_size(); m_width[window_index] = wdim.width(); m_height[window_index] = wdim.height(); - if (view_index == first_view_index) + if (window_index == 0) { if ((m_dimensions != osd_dim(m_width[window_index], m_height[window_index]))) { @@ -829,6 +837,7 @@ int renderer_bgfx::draw(int update) bool atlas_valid = update_atlas(); render_primitive *prim = window().m_primlist->first(); + int32_t screen = 0; while (prim != nullptr) { UINT32 blend = PRIMFLAG_GET_BLENDMODE(prim->flags); @@ -836,9 +845,14 @@ int renderer_bgfx::draw(int update) bgfx::TransientVertexBuffer buffer; allocate_buffer(prim, blend, &buffer); - buffer_status status = buffer_primitives(view_index, atlas_valid, &prim, &buffer); + buffer_status status = buffer_primitives(view_index, atlas_valid, &prim, &buffer, screen); + + if (status == BUFFER_SCREEN) + { + screen++; + } - if (status != BUFFER_EMPTY) + if (status != BUFFER_EMPTY && status != BUFFER_SCREEN) { bgfx::setVertexBuffer(&buffer); bgfx::setTexture(0, m_gui_effect[blend]->uniform("s_tex")->handle(), m_texture_cache->texture()); @@ -867,7 +881,7 @@ int renderer_bgfx::draw(int update) return 0; } -renderer_bgfx::buffer_status renderer_bgfx::buffer_primitives(int view, bool atlas_valid, render_primitive** prim, bgfx::TransientVertexBuffer* buffer) +renderer_bgfx::buffer_status renderer_bgfx::buffer_primitives(int view, bool atlas_valid, render_primitive** prim, bgfx::TransientVertexBuffer* buffer, int32_t screen) { int vertices = 0; @@ -902,15 +916,16 @@ renderer_bgfx::buffer_status renderer_bgfx::buffer_primitives(int view, bool atl return BUFFER_PRE_FLUSH; } - if (PRIMFLAG_GET_SCREENTEX((*prim)->flags)) + if (PRIMFLAG_GET_SCREENTEX((*prim)->flags) && m_screen_chain != nullptr) { - render_post_screen_quad(view, *prim, buffer); + render_post_screen_quad(view, *prim, buffer, screen); + return BUFFER_SCREEN; } else { render_textured_quad(view, *prim, buffer); + return BUFFER_EMPTY; } - return BUFFER_EMPTY; } } break; @@ -1121,6 +1136,11 @@ void renderer_bgfx::allocate_buffer(render_primitive *prim, UINT32 blend, bgfx:: slider_state* renderer_bgfx::get_slider_list() { + if (!m_screen_chain) + { + return nullptr; + } + slider_state *listhead = nullptr; slider_state **tailptr = &listhead; std::vector sliders = m_screen_chain->sliders(); diff --git a/src/osd/modules/render/drawbgfx.h b/src/osd/modules/render/drawbgfx.h index 2c4fc934a26..793f0340767 100644 --- a/src/osd/modules/render/drawbgfx.h +++ b/src/osd/modules/render/drawbgfx.h @@ -67,14 +67,15 @@ private: { BUFFER_PRE_FLUSH, BUFFER_FLUSH, + BUFFER_SCREEN, BUFFER_EMPTY, BUFFER_DONE }; - buffer_status buffer_primitives(int view, bool atlas_valid, render_primitive** prim, bgfx::TransientVertexBuffer* buffer); + buffer_status buffer_primitives(int view, bool atlas_valid, render_primitive** prim, bgfx::TransientVertexBuffer* buffer, int32_t screen); void process_screen_quad(int view, render_primitive* prim); void render_textured_quad(int view, render_primitive* prim, bgfx::TransientVertexBuffer* buffer); - void render_post_screen_quad(int view, render_primitive* prim, bgfx::TransientVertexBuffer* buffer); + void render_post_screen_quad(int view, render_primitive* prim, bgfx::TransientVertexBuffer* buffer, int32_t screen); void put_packed_quad(render_primitive *prim, UINT32 hash, ScreenVertex* vertex); void put_polygon(const float* coords, UINT32 num_coords, float r, UINT32 rgba, ScreenVertex* vertex); -- cgit v1.2.3