More BGFX stability improvements (missing files + multi-window) (#9410)

* -bgfx: Improved stability when encountering missing files, and improved multi-window stability. [Ryan Holtz]

* -osd: Added video-init fallback functionality to other OSDs. [Ryan Holtz]

src/osd/mac/window.cpp

@@ -69,17 +69,43 @@ bool mac_osd_interface::window_init()
 {
 	osd_printf_verbose("Enter macwindow_init\n");
 
-	// initialize the drawers
+	// initialize the renderer
+	const int fallbacks[VIDEO_MODE_COUNT] = {
+		-1,                 // NONE -> no fallback
+		-1,                 // No GDI on macOS
+		VIDEO_MODE_OPENGL,  // BGFX -> OpenGL
+		-1,                 // OpenGL -> no fallback
+		-1,                 // No SDL2ACCEL on macOS
+		-1,                 // No D3D on macOS
+		-1                  // No SOFT on macOS
+	};
 
-	switch (video_config.mode)
+	int current_mode = video_config.mode;
+	while (current_mode != VIDEO_MODE_NONE)
 	{
-		case VIDEO_MODE_BGFX:
-			renderer_bgfx::init(machine());
-			break;
-		case VIDEO_MODE_OPENGL:
-			renderer_ogl::init(machine());
+		bool error = false;
+		switch(current_mode)
+		{
+			case VIDEO_MODE_BGFX:
+				error = renderer_bgfx::init(machine());
+				break;
+			case VIDEO_MODE_OPENGL:
+				renderer_ogl::init(machine());
+				break;
+			default:
+				fatalerror("Unknown video mode.");
+				break;
+		}
+		if (error)
+		{
+			current_mode = fallbacks[current_mode];
+		}
+		else
+		{
 			break;
+		}
 	}
+	video_config.mode = current_mode;
 
 	// set up the window list
 	osd_printf_verbose("Leave macwindow_init\n");

src/osd/modules/render/bgfx/chainentryreader.cpp

@@ -35,11 +35,11 @@ bgfx_chain_entry* chain_entry_reader::read_from_value(const Value& value, std::s
 {
 	if (!validate_parameters(value, prefix))
 	{
-		printf("Failed validation\n");
+		osd_printf_error("Chain entry failed validation.\n");
 		return nullptr;
 	}
 
-	bgfx_effect* effect = chains.effects().effect(value["effect"].GetString());
+	bgfx_effect* effect = chains.effects().get_or_load_effect(chains.options(), value["effect"].GetString());
 	if (effect == nullptr)
 	{
 		return nullptr;

src/osd/modules/render/bgfx/chainmanager.cpp

@@ -61,11 +61,11 @@ chain_manager::~chain_manager()
 void chain_manager::init_texture_converters()
 {
 	m_converters.push_back(nullptr);
-	m_converters.push_back(m_effects.effect("misc/texconv_palette16"));
-	m_converters.push_back(m_effects.effect("misc/texconv_rgb32"));
+	m_converters.push_back(m_effects.get_or_load_effect(m_options, "misc/texconv_palette16"));
+	m_converters.push_back(m_effects.get_or_load_effect(m_options, "misc/texconv_rgb32"));
 	m_converters.push_back(nullptr);
-	m_converters.push_back(m_effects.effect("misc/texconv_yuy16"));
-	m_adjuster = m_effects.effect("misc/bcg_adjust");
+	m_converters.push_back(m_effects.get_or_load_effect(m_options, "misc/texconv_yuy16"));
+	m_adjuster = m_effects.get_or_load_effect(m_options, "misc/bcg_adjust");
 }
 
 void chain_manager::refresh_available_chains()

src/osd/modules/render/bgfx/effect.h

@@ -26,7 +26,8 @@ public:
 	~bgfx_effect();
 
 	void submit(int view, uint64_t blend = 0L);
-	bgfx_uniform* uniform(std::string name);
+	bgfx_uniform *uniform(std::string name);
+	bool is_valid() { return m_program_handle.idx != bgfx::kInvalidHandle; }
 
 private:
 	uint64_t                             m_state;

src/osd/modules/render/bgfx/effectmanager.cpp

@@ -23,7 +23,45 @@
 #include "effectreader.h"
 #include "effect.h"
 
-using namespace rapidjson;
+static bool prepare_effect_document(std::string &name, osd_options &options, rapidjson::Document &document)
+{
+	std::string full_name = name;
+	if (full_name.length() < 5 || (full_name.compare(full_name.length() - 5, 5, ".json") != 0))
+	{
+		full_name = full_name + ".json";
+	}
+
+	std::string path;
+	osd_subst_env(path, util::string_format("%s" PATH_SEPARATOR "effects" PATH_SEPARATOR, options.bgfx_path()));
+	path += full_name;
+
+	bx::FileReader reader;
+	if (!bx::open(&reader, path.c_str()))
+	{
+		osd_printf_error("Unable to open effect file %s\n", path.c_str());
+		return false;
+	}
+
+	int32_t size (bx::getSize(&reader));
+	char* data = new char[size + 1];
+	bx::read(&reader, reinterpret_cast<void*>(data), size);
+	bx::close(&reader);
+	data[size] = 0;
+
+	document.Parse<rapidjson::kParseCommentsFlag>(data);
+
+	delete [] data;
+
+	if (document.HasParseError())
+	{
+		std::string error(rapidjson::GetParseError_En(document.GetParseError()));
+		osd_printf_error("Unable to parse effect %s. Errors returned:\n", path.c_str());
+		osd_printf_error("%s\n", error.c_str());
+		return false;
+	}
+
+	return true;
+}
 
 effect_manager::~effect_manager()
 {
@@ -34,7 +72,7 @@ effect_manager::~effect_manager()
 	m_effects.clear();
 }
 
-bgfx_effect* effect_manager::effect(std::string name)
+bgfx_effect* effect_manager::get_or_load_effect(osd_options &options, std::string name)
 {
 	std::map<std::string, bgfx_effect*>::iterator iter = m_effects.find(name);
 	if (iter != m_effects.end())
@@ -42,49 +80,22 @@ bgfx_effect* effect_manager::effect(std::string name)
 		return iter->second;
 	}
 
-	return load_effect(name);
+	return load_effect(options, name);
 }
 
-bgfx_effect* effect_manager::load_effect(std::string name)
+bgfx_effect* effect_manager::load_effect(osd_options &options, std::string name)
 {
-	std::string full_name = name;
-	if (full_name.length() < 5 || (full_name.compare(full_name.length() - 5, 5, ".json") != 0)) {
-		full_name = full_name + ".json";
-	}
-	std::string path;
-	osd_subst_env(path, util::string_format("%s" PATH_SEPARATOR "effects" PATH_SEPARATOR, m_options.bgfx_path()));
-	path += full_name;
-
-	bx::FileReader reader;
-	if (!bx::open(&reader, path.c_str()))
+	rapidjson::Document document;
+	if (!prepare_effect_document(name, options, document))
 	{
-		printf("Unable to open effect file %s\n", path.c_str());
 		return nullptr;
 	}
 
-	int32_t size (bx::getSize(&reader));
+	bgfx_effect* effect = effect_reader::read_from_value(document, "Effect '" + name + "': ", options, m_shaders);
 
-	char* data = new char[size + 1];
-	bx::read(&reader, reinterpret_cast<void*>(data), size);
-	bx::close(&reader);
-	data[size] = 0;
-
-	Document document;
-	document.Parse<kParseCommentsFlag>(data);
-
-	delete [] data;
-
-	if (document.HasParseError()) {
-		std::string error(GetParseError_En(document.GetParseError()));
-		printf("Unable to parse effect %s. Errors returned:\n", path.c_str());
-		printf("%s\n", error.c_str());
-		return nullptr;
-	}
-
-	bgfx_effect* effect = effect_reader::read_from_value(document, "Effect '" + name + "': ", m_shaders);
-
-	if (effect == nullptr) {
-		printf("Unable to load effect %s\n", path.c_str());
+	if (effect == nullptr)
+	{
+		osd_printf_error("Unable to load effect %s\n", name.c_str());
 		return nullptr;
 	}
 
@@ -92,3 +103,14 @@ bgfx_effect* effect_manager::load_effect(std::string name)
 
 	return effect;
 }
+
+bool effect_manager::validate_effect(osd_options &options, std::string name)
+{
+	rapidjson::Document document;
+	if (!prepare_effect_document(name, options, document))
+	{
+		return false;
+	}
+
+	return effect_reader::validate_value(document, "Effect '" + name + "': ", options);
+}

src/osd/modules/render/bgfx/effectmanager.h

@@ -25,16 +25,16 @@ class bgfx_effect;
 
 class effect_manager {
 public:
-	effect_manager(osd_options& options, shader_manager& shaders) : m_options(options), m_shaders(shaders) { }
+	effect_manager(shader_manager& shaders) : m_shaders(shaders) { }
 	~effect_manager();
 
 	// Getters
-	bgfx_effect* effect(std::string name);
+	bgfx_effect* get_or_load_effect(osd_options &options, std::string name);
+	static bool validate_effect(osd_options &options, std::string name);
 
 private:
-	bgfx_effect* load_effect(std::string name);
+	bgfx_effect* load_effect(osd_options& options, std::string name);
 
-	osd_options&                        m_options;
 	shader_manager&                     m_shaders;
 	std::map<std::string, bgfx_effect*> m_effects;
 };

src/osd/modules/render/bgfx/effectreader.cpp

@@ -23,11 +23,80 @@
 
 #include "effectreader.h"
 
-bgfx_effect* effect_reader::read_from_value(const Value& value, std::string prefix, shader_manager& shaders)
+bgfx_effect *effect_reader::read_from_value(const Value& value, std::string prefix, osd_options &options, shader_manager& shaders)
+{
+	uint64_t flags = 0;
+	std::string vertex_name;
+	std::string fragment_name;
+	bgfx::ShaderHandle vertex_shader = BGFX_INVALID_HANDLE;
+	bgfx::ShaderHandle fragment_shader = BGFX_INVALID_HANDLE;
+	std::vector<bgfx_uniform *> uniforms;
+
+	if (!get_base_effect_data(value, prefix, flags, vertex_name, fragment_name, uniforms))
+	{
+		return nullptr;
+	}
+
+	if (!get_shader_data(value, options, shaders, vertex_name, vertex_shader, fragment_name, fragment_shader))
+	{
+		clear_uniform_list(uniforms);
+		return nullptr;
+	}
+
+	bgfx_effect *effect = new bgfx_effect(flags, vertex_shader, fragment_shader, uniforms);
+	if (effect->is_valid())
+	{
+		return effect;
+	}
+
+	delete effect;
+
+	return nullptr;
+}
+
+bool effect_reader::validate_value(const Value& value, std::string prefix, osd_options &options)
 {
 	if (!validate_parameters(value, prefix))
 	{
-		return nullptr;
+		return false;
+	}
+
+	uint64_t flags = 0;
+	std::string vertex_name;
+	std::string fragment_name;
+	bgfx::ShaderHandle vertex_shader = BGFX_INVALID_HANDLE;
+	bgfx::ShaderHandle fragment_shader = BGFX_INVALID_HANDLE;
+	std::vector<bgfx_uniform *> uniforms;
+
+	if (!get_base_effect_data(value, prefix, flags, vertex_name, fragment_name, uniforms))
+	{
+		return false;
+	}
+
+	if (!get_shader_data(value, options, vertex_name, vertex_shader, fragment_name, fragment_shader))
+	{
+		clear_uniform_list(uniforms);
+		return false;
+	}
+
+	bgfx::ProgramHandle program = bgfx::createProgram(vertex_shader, fragment_shader, true);
+
+	bool success = false;
+	if (program.idx != bgfx::kInvalidHandle)
+	{
+		success = true;
+		bgfx::destroy(program);
+	}
+
+	return success;
+}
+
+bool effect_reader::get_base_effect_data(const Value& value, std::string &prefix, uint64_t &flags, std::string &vertex_name, std::string &fragment_name,
+	std::vector<bgfx_uniform *> &uniforms)
+{
+	if (!validate_parameters(value, prefix))
+	{
+		return false;
 	}
 
 	uint64_t blend = 0;
@@ -38,34 +107,21 @@ bgfx_effect* effect_reader::read_from_value(const Value& value, std::string pref
 	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"]);
+	flags = blend | depth | cull | write;
 
-	std::vector<bgfx_uniform*> uniforms;
 	const Value& uniform_array = value["uniforms"];
 	for (uint32_t i = 0; i < uniform_array.Size(); i++)
 	{
-		bgfx_uniform* uniform = uniform_reader::read_from_value(uniform_array[i], prefix + "uniforms[" + std::to_string(i) + "]: ");
+		bgfx_uniform *uniform = uniform_reader::read_from_value(uniform_array[i], prefix + "uniforms[" + std::to_string(i) + "]: ");
 		if (uniform == nullptr)
 		{
-			return nullptr;
+			return false;
 		}
 		uniforms.push_back(uniform);
 	}
 
-	std::string vertex_name(value["vertex"].GetString());
-	bgfx::ShaderHandle vertex_shader = shaders.shader(vertex_name);
-	if (vertex_shader.idx == 0xffff)
-	{
-		for (bgfx_uniform* uniform : uniforms)
-		{
-			if (uniform != nullptr)
-			{
-				delete uniform;
-			}
-		}
-		return nullptr;
-	}
+	vertex_name = value["vertex"].GetString();
 
-	std::string fragment_name("");
 	if (value.HasMember("fragment"))
 	{
 		fragment_name = value["fragment"].GetString();
@@ -74,20 +130,59 @@ bgfx_effect* effect_reader::read_from_value(const Value& value, std::string pref
 	{
 		fragment_name = value["pixel"].GetString();
 	}
-	bgfx::ShaderHandle fragment_shader = shaders.shader(fragment_name);
-	if (fragment_shader.idx == 0xffff)
+	else
 	{
-		for (bgfx_uniform* uniform : uniforms)
-		{
-			if (uniform != nullptr)
-			{
-				delete uniform;
-			}
-		}
-		return nullptr;
+		fragment_name = "";
 	}
 
-	return new bgfx_effect(blend | depth | cull | write, vertex_shader, fragment_shader, uniforms);
+	return true;
+}
+
+bool effect_reader::get_shader_data(const Value& value, osd_options &options, shader_manager &shaders, std::string &vertex_name, bgfx::ShaderHandle &vertex_shader,
+	std::string &fragment_name, bgfx::ShaderHandle &fragment_shader)
+{
+	vertex_shader = shaders.load_shader(options, vertex_name);
+	if (vertex_shader.idx == bgfx::kInvalidHandle)
+	{
+		return false;
+	}
+
+	fragment_shader = shaders.load_shader(options, fragment_name);
+	if (fragment_shader.idx == bgfx::kInvalidHandle)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+bool effect_reader::get_shader_data(const Value& value, osd_options &options, std::string &vertex_name, bgfx::ShaderHandle &vertex_shader, std::string &fragment_name,
+	bgfx::ShaderHandle &fragment_shader)
+{
+	vertex_shader = shader_manager::load_shader(options, vertex_name);
+	if (vertex_shader.idx == bgfx::kInvalidHandle)
+	{
+		return false;
+	}
+
+	fragment_shader = shader_manager::load_shader(options, fragment_name);
+	if (fragment_shader.idx == bgfx::kInvalidHandle)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+void effect_reader::clear_uniform_list(std::vector<bgfx_uniform *> &uniforms)
+{
+	for (bgfx_uniform *uniform : uniforms)
+	{
+		if (uniform != nullptr)
+		{
+			delete uniform;
+		}
+	}
 }
 
 bool effect_reader::validate_parameters(const Value& value, std::string prefix)

src/osd/modules/render/bgfx/effectreader.h

@@ -16,14 +16,23 @@
 #include "statereader.h"
 
 class bgfx_effect;
+class bgfx_uniform;
 class shader_manager;
 
 class effect_reader : public state_reader
 {
 public:
-	static bgfx_effect* read_from_value(const Value& value, std::string prefix, shader_manager& shaders);
+	static bgfx_effect *read_from_value(const Value& value, std::string prefix, osd_options &options, shader_manager& shaders);
+	static bool validate_value(const Value& value, std::string prefix, osd_options &options);
 
 private:
+	static bool get_base_effect_data(const Value& value, std::string &prefix, uint64_t &flags, std::string &vertex_name, std::string &fragment_name,
+		std::vector<bgfx_uniform *> &uniforms);
+	static bool get_shader_data(const Value& value, osd_options &options, shader_manager &shaders, std::string &vertex_name, bgfx::ShaderHandle &vertex_shader,
+		std::string &fragment_name, bgfx::ShaderHandle &fragment_shader);
+	static bool get_shader_data(const Value& value, osd_options &options, std::string &vertex_name, bgfx::ShaderHandle &vertex_shader, std::string &fragment_name,
+		bgfx::ShaderHandle &fragment_shader);
+	static void clear_uniform_list(std::vector<bgfx_uniform *> &uniforms);
 	static bool validate_parameters(const Value& value, std::string prefix);
 };
 

src/osd/modules/render/bgfx/shadermanager.cpp

@@ -28,7 +28,7 @@ shader_manager::~shader_manager()
 	m_shaders.clear();
 }
 
-bgfx::ShaderHandle shader_manager::shader(std::string name)
+bgfx::ShaderHandle shader_manager::get_or_load_shader(osd_options &options, std::string name)
 {
 	std::map<std::string, bgfx::ShaderHandle>::iterator iter = m_shaders.find(name);
 	if (iter != m_shaders.end())
@@ -36,12 +36,18 @@ bgfx::ShaderHandle shader_manager::shader(std::string name)
 		return iter->second;
 	}
 
-	return load_shader(name);
+	bgfx::ShaderHandle handle = load_shader(options, name);
+	if (handle.idx != bgfx::kInvalidHandle)
+	{
+		m_shaders[name] = handle;
+	}
+
+	return handle;
 }
 
-bgfx::ShaderHandle shader_manager::load_shader(std::string name)
+bgfx::ShaderHandle shader_manager::load_shader(osd_options &options, std::string name)
 {
-	std::string shader_path(m_options.bgfx_path());
+	std::string shader_path(options.bgfx_path());
 	shader_path += PATH_SEPARATOR "shaders" PATH_SEPARATOR;
 	switch (bgfx::getRendererType())
 	{
@@ -84,11 +90,7 @@ bgfx::ShaderHandle shader_manager::load_shader(std::string name)
 	const bgfx::Memory* mem = load_mem(shader_path + name + ".bin");
 	if (mem != nullptr)
 	{
-		bgfx::ShaderHandle handle = bgfx::createShader(mem);
-
-		m_shaders[name] = handle;
-
-		return handle;
+		return bgfx::createShader(mem);
 	}
 
 	return BGFX_INVALID_HANDLE;
@@ -109,7 +111,7 @@ const bgfx::Memory* shader_manager::load_mem(std::string name)
 	}
 	else
 	{
-		printf("Unable to load shader %s\n", name.c_str());
+		osd_printf_error("Unable to load shader %s\n", name.c_str());
 	}
 	return nullptr;
 }

src/osd/modules/render/bgfx/shadermanager.h

@@ -24,18 +24,17 @@
 
 class shader_manager {
 public:
-	shader_manager(osd_options& options) : m_options(options) { }
+	shader_manager() { }
 	~shader_manager();
 
 	// Getters
-	bgfx::ShaderHandle shader(std::string name);
+	bgfx::ShaderHandle get_or_load_shader(osd_options &options, std::string name);
+	static bgfx::ShaderHandle load_shader(osd_options &options, std::string name);
 
 private:
-	bgfx::ShaderHandle load_shader(std::string name);
 	static const bgfx::Memory* load_mem(std::string name);
 
 	std::map<std::string, bgfx::ShaderHandle>   m_shaders;
-	osd_options&                                m_options;
 };
 
 #endif // __DRAWBGFX_SHADER_MANAGER__

src/osd/modules/render/bgfx/texturemanager.cpp

@@ -68,7 +68,7 @@ bgfx_texture* texture_manager::create_png_texture(std::string path, std::string
 
 	if (bitmap.width() == 0 || bitmap.height() == 0)
 	{
-		printf("Unable to load PNG '%s' from path '%s'\n", file_name.c_str(), path.c_str());
+		osd_printf_error("Unable to load PNG '%s' from path '%s'\n", file_name.c_str(), path.c_str());
 		return nullptr;
 	}
 

src/osd/modules/render/bgfx/view.cpp

@@ -26,11 +26,7 @@ void bgfx_view::update() {
 }
 
 void bgfx_ortho_view::setup() {
-	if (m_window_index != 0)
-	{
-		bgfx::setViewFrameBuffer(m_index, m_backbuffer->target());
-	}
-
+	bgfx::setViewFrameBuffer(m_index, m_backbuffer->target());
 	bgfx::setViewRect(m_index, 0, 0, m_view_width, m_view_height);
 
 	while ((m_index + 1) > m_seen_views.size())

src/osd/modules/render/drawbgfx.cpp

@@ -75,7 +75,6 @@ char const *const renderer_bgfx::WINDOW_PREFIX = "Window 0, ";
 //  STATICS
 //============================================================
 
-bool renderer_bgfx::s_window_set = false;
 uint32_t renderer_bgfx::s_current_view = 0;
 
 //============================================================
@@ -217,113 +216,36 @@ int renderer_bgfx::create()
 	osd_dim wdim = win->get_size();
 	m_width[win->index()] = wdim.width();
 	m_height[win->index()] = wdim.height();
-	if (win->index() == 0)
-	{
-		if (!s_window_set)
-		{
-			s_window_set = true;
-			ScreenVertex::init();
-		}
-		else
-		{
-			bgfx::shutdown();
-			bgfx::PlatformData blank_pd;
-			memset(&blank_pd, 0, sizeof(bgfx::PlatformData));
-			bgfx::setPlatformData(blank_pd);
-		}
-#ifdef OSD_WINDOWS
-		winSetHwnd(std::static_pointer_cast<win_window_info>(win)->platform_window());
-#elif defined(OSD_MAC)
-		macSetWindow(std::static_pointer_cast<mac_window_info>(win)->platform_window());
-#else
-		sdlSetWindow(std::dynamic_pointer_cast<sdl_window_info>(win)->platform_window());
-#endif
-		std::string backend(m_options.bgfx_backend());
-		bgfx::Init init;
-		init.type = bgfx::RendererType::Count;
-		init.vendorId = BGFX_PCI_ID_NONE;
-		init.resolution.width = wdim.width();
-		init.resolution.height = wdim.height();
-		init.resolution.reset = BGFX_RESET_NONE;
-		if (backend == "auto")
-		{
-		}
-		else if (backend == "dx9" || backend == "d3d9")
-		{
-			init.type = bgfx::RendererType::Direct3D9;
-		}
-		else if (backend == "dx11" || backend == "d3d11")
-		{
-			init.type = bgfx::RendererType::Direct3D11;
-		}
-		else if (backend == "dx12" || backend == "d3d12")
-		{
-			init.type = bgfx::RendererType::Direct3D12;
-		}
-		else if (backend == "gles")
-		{
-			init.type = bgfx::RendererType::OpenGLES;
-		}
-		else if (backend == "glsl" || backend == "opengl")
-		{
-			init.type = bgfx::RendererType::OpenGL;
-		}
-		else if (backend == "vulkan")
-		{
-			init.type = bgfx::RendererType::Vulkan;
-		}
-		else if (backend == "metal")
-		{
-			init.type = bgfx::RendererType::Metal;
-		}
-		else
-		{
-			printf("Unknown backend type '%s', going with auto-detection\n", backend.c_str());
-		}
-		bgfx::init(init);
-		bgfx::reset(m_width[win->index()], m_height[win->index()], video_config.waitvsync ? BGFX_RESET_VSYNC : BGFX_RESET_NONE);
-		// Enable debug text.
-		bgfx::setDebug(m_options.bgfx_debug() ? BGFX_DEBUG_STATS : BGFX_DEBUG_TEXT);
-		m_dimensions = osd_dim(m_width[0], m_height[0]);
-	}
+	m_dimensions = wdim;
 
 	m_textures = new texture_manager();
 	m_targets = new target_manager(*m_textures);
 
-	m_shaders = new shader_manager(m_options);
-	m_effects = new effect_manager(m_options, *m_shaders);
-
-	if (win->index() != 0)
-	{
-#ifdef OSD_WINDOWS
-		m_framebuffer = m_targets->create_backbuffer(std::static_pointer_cast<win_window_info>(win)->platform_window(), m_width[win->index()], m_height[win->index()]);
-#elif defined(OSD_MAC)
-		m_framebuffer = m_targets->create_backbuffer(GetOSWindow(std::static_pointer_cast<mac_window_info>(win)->platform_window()), m_width[win->index()], m_height[win->index()]);
-#else
-		m_framebuffer = m_targets->create_backbuffer(sdlNativeWindowHandle(std::dynamic_pointer_cast<sdl_window_info>(win)->platform_window()), m_width[win->index()], m_height[win->index()]);
-#endif
-		bgfx::touch(win->index());
-
-		if (m_ortho_view) {
-			m_ortho_view->set_backbuffer(m_framebuffer);
-		}
-	}
+	m_shaders = new shader_manager();
+	m_effects = new effect_manager(*m_shaders);
 
 	// Create program from shaders.
-	m_gui_effect[0] = m_effects->effect("gui_opaque");
-	m_gui_effect[1] = m_effects->effect("gui_blend");
-	m_gui_effect[2] = m_effects->effect("gui_multiply");
-	m_gui_effect[3] = m_effects->effect("gui_add");
+	m_gui_effect[0] = m_effects->get_or_load_effect(m_options, "gui_opaque");
+	m_gui_effect[1] = m_effects->get_or_load_effect(m_options, "gui_blend");
+	m_gui_effect[2] = m_effects->get_or_load_effect(m_options, "gui_multiply");
+	m_gui_effect[3] = m_effects->get_or_load_effect(m_options, "gui_add");
 
-	m_screen_effect[0] = m_effects->effect("screen_opaque");
-	m_screen_effect[1] = m_effects->effect("screen_blend");
-	m_screen_effect[2] = m_effects->effect("screen_multiply");
-	m_screen_effect[3] = m_effects->effect("screen_add");
+	m_screen_effect[0] = m_effects->get_or_load_effect(m_options, "screen_opaque");
+	m_screen_effect[1] = m_effects->get_or_load_effect(m_options, "screen_blend");
+	m_screen_effect[2] = m_effects->get_or_load_effect(m_options, "screen_multiply");
+	m_screen_effect[3] = m_effects->get_or_load_effect(m_options, "screen_add");
 
-	if (   m_gui_effect[0] == nullptr ||    m_gui_effect[1] == nullptr ||    m_gui_effect[2] == nullptr ||    m_gui_effect[3] == nullptr ||
-		m_screen_effect[0] == nullptr || m_screen_effect[1] == nullptr || m_screen_effect[2] == nullptr || m_screen_effect[3] == nullptr)
-	{
-		fatalerror("BGFX: Unable to load required shaders. Please check and reinstall the %s folder\n", m_options.bgfx_path());
+#ifdef OSD_WINDOWS
+	m_framebuffer = m_targets->create_backbuffer(std::static_pointer_cast<win_window_info>(win)->platform_window(), m_width[win->index()], m_height[win->index()]);
+#elif defined(OSD_MAC)
+	m_framebuffer = m_targets->create_backbuffer(GetOSWindow(std::static_pointer_cast<mac_window_info>(win)->platform_window()), m_width[win->index()], m_height[win->index()]);
+#else
+	m_framebuffer = m_targets->create_backbuffer(sdlNativeWindowHandle(std::dynamic_pointer_cast<sdl_window_info>(win)->platform_window()), m_width[win->index()], m_height[win->index()]);
+#endif
+	bgfx::touch(win->index());
+
+	if (m_ortho_view) {
+		m_ortho_view->set_backbuffer(m_framebuffer);
 	}
 
 	m_chains = new chain_manager(win->machine(), m_options, *m_textures, *m_targets, *m_effects, win->index(), *this);
@@ -335,8 +257,6 @@ int renderer_bgfx::create()
 	memset(m_white, 0xff, sizeof(uint32_t) * 16 * 16);
 	m_texinfo.push_back(rectangle_packer::packable_rectangle(WHITE_HASH, PRIMFLAG_TEXFORMAT(TEXFORMAT_ARGB32), 16, 16, 16, nullptr, m_white));
 
-	imguiCreate();
-
 	return 0;
 }
 
@@ -384,24 +304,97 @@ void renderer_bgfx::record()
 
 bool renderer_bgfx::init(running_machine &machine)
 {
-	const char *bgfx_path = downcast<osd_options &>(machine.options()).bgfx_path();
+	osd_options &options = downcast<osd_options &>(machine.options());
+	const char *bgfx_path = options.bgfx_path();
+	std::string backend(options.bgfx_backend());
 
 	osd::directory::ptr directory = osd::directory::open(bgfx_path);
 	if (directory == nullptr)
 	{
-		osd_printf_verbose("Unable to find the %s folder. Please reinstall it to use the BGFX renderer\n", bgfx_path);
+		osd_printf_error("Unable to find the BGFX path %s, please install it or fix the bgfx_path setting to use the BGFX renderer.\n", bgfx_path);
 		return true;
 	}
 
+	bgfx::Init init;
+	init.type = bgfx::RendererType::Count;
+	init.vendorId = BGFX_PCI_ID_NONE;
+	init.resolution.width = 0;
+	init.resolution.height = 0;
+	init.resolution.numBackBuffers = 0;
+	init.resolution.reset = BGFX_RESET_NONE;
+	if (backend == "auto")
+	{
+	}
+	else if (backend == "dx9" || backend == "d3d9")
+	{
+		init.type = bgfx::RendererType::Direct3D9;
+	}
+	else if (backend == "dx11" || backend == "d3d11")
+	{
+		init.type = bgfx::RendererType::Direct3D11;
+	}
+	else if (backend == "dx12" || backend == "d3d12")
+	{
+		init.type = bgfx::RendererType::Direct3D12;
+	}
+	else if (backend == "gles")
+	{
+		init.type = bgfx::RendererType::OpenGLES;
+	}
+	else if (backend == "glsl" || backend == "opengl")
+	{
+		init.type = bgfx::RendererType::OpenGL;
+	}
+	else if (backend == "vulkan")
+	{
+		init.type = bgfx::RendererType::Vulkan;
+	}
+	else if (backend == "metal")
+	{
+		init.type = bgfx::RendererType::Metal;
+	}
+	else
+	{
+		osd_printf_verbose("Unknown backend type '%s', going with auto-detection.\n", backend.c_str());
+	}
+
+	bgfx::init(init);
+	bgfx::reset(16, 16, video_config.waitvsync ? BGFX_RESET_VSYNC : BGFX_RESET_NONE);
+	// Enable debug text if requested.
+	bool bgfx_debug = downcast<osd_options &>(machine.options()).bgfx_debug();
+	bgfx::setDebug(bgfx_debug ? BGFX_DEBUG_STATS : BGFX_DEBUG_TEXT);
+
+	ScreenVertex::init();
+
+	// Verify baseline shaders.
+	const bool gui_opaque_valid = effect_manager::validate_effect(options, "gui_opaque");
+	const bool gui_blend_valid = effect_manager::validate_effect(options, "gui_blend");
+	const bool gui_multiply_valid = effect_manager::validate_effect(options, "gui_multiply");
+	const bool gui_add_valid = effect_manager::validate_effect(options, "gui_add");
+	const bool all_gui_valid = gui_opaque_valid && gui_blend_valid && gui_multiply_valid && gui_add_valid;
+
+	const bool screen_opaque_valid = effect_manager::validate_effect(options, "screen_opaque");
+	const bool screen_blend_valid = effect_manager::validate_effect(options, "screen_blend");
+	const bool screen_multiply_valid = effect_manager::validate_effect(options, "screen_multiply");
+	const bool screen_add_valid = effect_manager::validate_effect(options, "screen_add");
+	const bool all_screen_valid = screen_opaque_valid && screen_blend_valid && screen_multiply_valid && screen_add_valid;
+
+	if (!all_gui_valid || !all_screen_valid)
+	{
+		osd_printf_error("BGFX: Unable to load required shaders. Please update the %s folder or adjust your bgfx_path setting.\n", options.bgfx_path());
+		bgfx::shutdown();
+		return true;
+	}
+
+	imguiCreate();
+
 	return false;
 }
 
 void renderer_bgfx::exit()
 {
 	imguiDestroy();
-
 	bgfx::shutdown();
-	s_window_set = false;
 }
 
 //============================================================
@@ -839,7 +832,8 @@ int renderer_bgfx::draw(int update)
 
 	if (num_screens)
 	{
-		s_current_view += m_chains->process_screen_chains(s_current_view, *win.get());
+		uint32_t chain_view_count = m_chains->process_screen_chains(s_current_view, *win.get());
+		s_current_view += chain_view_count;
 	}
 
 	bool skip_frame = update_dimensions();
@@ -918,10 +912,10 @@ int renderer_bgfx::draw(int update)
 			bgfx::touch(s_current_view);
 			update_recording();
 		}
-
-		bgfx::frame();
 	}
 
+	bgfx::frame();
+
 	return 0;
 }
 
@@ -962,39 +956,28 @@ bool renderer_bgfx::update_dimensions()
 	const uint32_t width = m_width[window_index];
 	const uint32_t height = m_height[window_index];
 
-	if (window_index == 0)
+	if ((m_dimensions != osd_dim(width, height)))
 	{
-		if ((m_dimensions != osd_dim(width, height)))
-		{
-			bgfx::reset(width, height, video_config.waitvsync ? BGFX_RESET_VSYNC : BGFX_RESET_NONE);
-			m_dimensions = osd_dim(width, height);
-		}
-	}
-	else
-	{
-		if ((m_dimensions != osd_dim(width, height)))
-		{
-			bgfx::reset(win->main_window()->get_size().width(), win->main_window()->get_size().height(), video_config.waitvsync ? BGFX_RESET_VSYNC : BGFX_RESET_NONE);
-			m_dimensions = osd_dim(width, height);
+		bgfx::reset(width, height, video_config.waitvsync ? BGFX_RESET_VSYNC : BGFX_RESET_NONE);
+		m_dimensions = osd_dim(width, height);
 
-			delete m_framebuffer;
+		delete m_framebuffer;
 #ifdef OSD_WINDOWS
-			m_framebuffer = m_targets->create_backbuffer(std::static_pointer_cast<win_window_info>(win)->platform_window(), width, height);
+		m_framebuffer = m_targets->create_backbuffer(std::static_pointer_cast<win_window_info>(win)->platform_window(), width, height);
 #elif defined(OSD_MAC)
-			m_framebuffer = m_targets->create_backbuffer(GetOSWindow(std::static_pointer_cast<mac_window_info>(win)->platform_window()), width, height);
+		m_framebuffer = m_targets->create_backbuffer(GetOSWindow(std::static_pointer_cast<mac_window_info>(win)->platform_window()), width, height);
 #else
-			m_framebuffer = m_targets->create_backbuffer(sdlNativeWindowHandle(std::dynamic_pointer_cast<sdl_window_info>(win)->platform_window()), width, height);
+		m_framebuffer = m_targets->create_backbuffer(sdlNativeWindowHandle(std::dynamic_pointer_cast<sdl_window_info>(win)->platform_window()), width, height);
 #endif
-			if (m_ortho_view)
-				m_ortho_view->set_backbuffer(m_framebuffer);
+		if (m_ortho_view)
+			m_ortho_view->set_backbuffer(m_framebuffer);
 
-			bgfx::setViewFrameBuffer(s_current_view, m_framebuffer->target());
-			bgfx::setViewClear(s_current_view, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x00000000, 1.0f, 0);
-			bgfx::setViewMode(s_current_view, bgfx::ViewMode::Sequential);
-			bgfx::touch(s_current_view);
-			bgfx::frame();
-			return true;
-		}
+		bgfx::setViewFrameBuffer(s_current_view, m_framebuffer->target());
+		bgfx::setViewClear(s_current_view, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x00000000, 1.0f, 0);
+		bgfx::setViewMode(s_current_view, bgfx::ViewMode::Sequential);
+		bgfx::touch(s_current_view);
+		bgfx::frame();
+		return true;
 	}
 	return false;
 }
@@ -1003,14 +986,15 @@ void renderer_bgfx::setup_ortho_view()
 {
 	if (!m_ortho_view)
 	{
-		m_ortho_view = new bgfx_ortho_view(this, s_current_view, m_framebuffer, m_seen_views);
+		m_ortho_view = new bgfx_ortho_view(this, 0, m_framebuffer, m_seen_views);
 	}
-	m_ortho_view->update();
-	if (m_ortho_view->get_index() == UINT_MAX) {
+	if (m_ortho_view->get_index() == UINT_MAX)
+	{
 		m_ortho_view->set_index(s_current_view);
 		m_ortho_view->setup();
 		s_current_view++;
 	}
+	m_ortho_view->update();
 }
 
 renderer_bgfx::buffer_status renderer_bgfx::buffer_primitives(bool atlas_valid, render_primitive** prim, bgfx::TransientVertexBuffer* buffer, int32_t screen)

src/osd/modules/render/drawbgfx.h

@@ -160,7 +160,6 @@ private:
 	static const uint32_t PACKABLE_SIZE;
 	static const uint32_t WHITE_HASH;
 
-	static bool s_window_set;
 	static uint32_t s_current_view;
 };
 

src/osd/sdl/window.cpp

@@ -92,25 +92,53 @@ bool sdl_osd_interface::window_init()
 {
 	osd_printf_verbose("Enter sdlwindow_init\n");
 
-	// initialize the drawers
-
-	switch (video_config.mode)
-	{
-		case VIDEO_MODE_BGFX:
-			renderer_bgfx::init(machine());
-			break;
+	// initialize the renderer
+	const int fallbacks[VIDEO_MODE_COUNT] = {
+		-1,						// NONE -> no fallback
+		-1,						// No GDI on Linux
+		VIDEO_MODE_OPENGL,		// BGFX -> OpenGL
 #if (USE_OPENGL)
-		case VIDEO_MODE_OPENGL:
-			renderer_ogl::init(machine());
-			break;
+		VIDEO_MODE_SDL2ACCEL,	// OpenGL -> SDL2Accel
 #endif
-		case VIDEO_MODE_SDL2ACCEL:
-			renderer_sdl2::init(machine());
-			break;
-		case VIDEO_MODE_SOFT:
-			renderer_sdl1::init(machine());
+		-1,						// SDL2ACCEL -> SOFT
+		-1,						// No D3D on Linux
+		-1,						// SOFT -> no fallback
+	};
+
+	int current_mode = video_config.mode;
+	while (current_mode != VIDEO_MODE_NONE)
+	{
+		bool error = false;
+		switch(current_mode)
+		{
+			case VIDEO_MODE_BGFX:
+				renderer_bgfx::init(machine());
+				break;
+#if (USE_OPENGL)
+			case VIDEO_MODE_OPENGL:
+				renderer_ogl::init(machine());
+				break;
+#endif
+			case VIDEO_MODE_SDL2ACCEL:
+				renderer_sdl2::init(machine());
+				break;
+			case VIDEO_MODE_SOFT:
+				renderer_sdl1::init(machine());
+				break;
+			default:
+				fatalerror("Unknown video mode.");
+				break;
+		}
+		if (error)
+		{
+			current_mode = fallbacks[current_mode];
+		}
+		else
+		{
 			break;
+		}
 	}
+	video_config.mode = current_mode;
 
 	/* We may want to set a number of the hints SDL2 provides.
 	 * The code below will document which hints were set.

src/osd/windows/window.cpp

@@ -130,6 +130,7 @@ bool windows_osd_interface::window_init()
 	window_thread = GetCurrentThread();
 	window_threadid = main_threadid;
 
+	// initialize the renderer
 	const int fallbacks[VIDEO_MODE_COUNT] = {
 		-1,                 // NONE -> no fallback
 		VIDEO_MODE_NONE,    // GDI -> NONE
@@ -151,7 +152,7 @@ bool windows_osd_interface::window_init()
 	{
 		bool error = false;
 		switch(current_mode)
-	{
+		{
 			case VIDEO_MODE_NONE:
 				error = renderer_none::init(machine());
 				break;