Fixed runtime renderer selection. (#3637)

examples/common/args.h

@@ -51,14 +51,26 @@ struct Args
 		{
 			m_pciId = BGFX_PCI_ID_AMD;
 		}
-		else if (cmdLine.hasArg("nvidia") )
+		else if (cmdLine.hasArg("apple") )
 		{
-			m_pciId = BGFX_PCI_ID_NVIDIA;
+			m_pciId = BGFX_PCI_ID_APPLE;
+		}
+		else if (cmdLine.hasArg("arm") )
+		{
+			m_pciId = BGFX_PCI_ID_ARM;
 		}
 		else if (cmdLine.hasArg("intel") )
 		{
 			m_pciId = BGFX_PCI_ID_INTEL;
 		}
+		else if (cmdLine.hasArg("nvidia") )
+		{
+			m_pciId = BGFX_PCI_ID_NVIDIA;
+		}
+		else if (cmdLine.hasArg("microsoft") )
+		{
+			m_pciId = BGFX_PCI_ID_MICROSOFT;
+		}
 		else if (cmdLine.hasArg("sw") )
 		{
 			m_pciId = BGFX_PCI_ID_SOFTWARE_RASTERIZER;

examples/common/entry/entry.cpp

@@ -4,6 +4,7 @@
  */
 
 #include <bx/bx.h>
+#include <bx/commandline.h>
 #include <bx/file.h>
 #include <bx/sort.h>
 #include <bgfx/bgfx.h>
@@ -375,8 +376,14 @@ BX_PRAGMA_DIAGNOSTIC_POP();
 	static AppI*    s_apps       = NULL;
 	static uint32_t s_numApps    = 0;
 
+	static char s_restartApp[1024] = { '\0' };
 	static char s_restartArgs[1024] = { '\0' };
 
+	void setRestartArgs(const char* _args)
+	{
+		bx::strCopy(s_restartArgs, BX_COUNTOF(s_restartArgs), _args);
+	}
+
 	static AppI* getCurrentApp(AppI* _set = NULL)
 	{
 		if (NULL != _set)
@@ -408,14 +415,14 @@ BX_PRAGMA_DIAGNOSTIC_POP();
 		{
 			if (2 == _argc)
 			{
-				bx::strCopy(s_restartArgs, BX_COUNTOF(s_restartArgs), getCurrentApp()->getName() );
+				bx::strCopy(s_restartApp, BX_COUNTOF(s_restartApp), getCurrentApp()->getName() );
 				return bx::kExitSuccess;
 			}
 
 			if (0 == bx::strCmp(_argv[2], "next") )
 			{
 				AppI* next = getNextWrap(getCurrentApp() );
-				bx::strCopy(s_restartArgs, BX_COUNTOF(s_restartArgs), next->getName() );
+				bx::strCopy(s_restartApp, BX_COUNTOF(s_restartApp), next->getName() );
 				return bx::kExitSuccess;
 			}
 			else if (0 == bx::strCmp(_argv[2], "prev") )
@@ -426,7 +433,7 @@ BX_PRAGMA_DIAGNOSTIC_POP();
 					prev = app;
 				}
 
-				bx::strCopy(s_restartArgs, BX_COUNTOF(s_restartArgs), prev->getName() );
+				bx::strCopy(s_restartApp, BX_COUNTOF(s_restartApp), prev->getName() );
 				return bx::kExitSuccess;
 			}
 
@@ -434,7 +441,7 @@ BX_PRAGMA_DIAGNOSTIC_POP();
 			{
 				if (0 == bx::strCmp(_argv[2], app->getName() ) )
 				{
-					bx::strCopy(s_restartArgs, BX_COUNTOF(s_restartArgs), app->getName() );
+					bx::strCopy(s_restartApp, BX_COUNTOF(s_restartApp), app->getName() );
 					return bx::kExitSuccess;
 				}
 			}
@@ -541,7 +548,7 @@ BX_PRAGMA_DIAGNOSTIC_POP();
 #else
 		while (_app->update() )
 		{
-			if (0 != bx::strLen(s_restartArgs) )
+			if (0 != bx::strLen(s_restartApp) )
 			{
 				break;
 			}
@@ -644,19 +651,45 @@ restart:
 		}
 
 		int32_t result = bx::kExitSuccess;
-		s_restartArgs[0] = '\0';
+		s_restartApp[0] = '\0';
 		if (0 == s_numApps)
 		{
 			result = ::_main_(_argc, (char**)_argv);
 		}
+		else if (0 != bx::strLen(s_restartArgs) )
+		{
+			char extraArgsBuf[256];
+			bx::strCopy(extraArgsBuf, BX_COUNTOF(extraArgsBuf), s_restartArgs);
+
+			const char* restartArgv[64];
+			int restartArgc = 0;
+
+			if (0 < _argc)
+			{
+				restartArgv[restartArgc++] = _argv[0];
+			}
+
+			char* extraArgv[32];
+			int extraArgc;
+			char tokenBuf[256];
+			uint32_t tokenBufSize = sizeof(tokenBuf);
+			bx::tokenizeCommandLine(extraArgsBuf, tokenBuf, tokenBufSize, extraArgc, extraArgv, BX_COUNTOF(extraArgv) );
+
+			for (int ii = 0; ii < extraArgc && restartArgc < (int)BX_COUNTOF(restartArgv) - 1; ++ii)
+			{
+				restartArgv[restartArgc++] = extraArgv[ii];
+			}
+
+			result = runApp(getCurrentApp(selected), restartArgc, restartArgv);
+		}
 		else
 		{
 			result = runApp(getCurrentApp(selected), _argc, _argv);
 		}
 
-		if (0 != bx::strLen(s_restartArgs) )
+		if (0 != bx::strLen(s_restartApp) )
 		{
-			find = s_restartArgs;
+			find = s_restartApp;
 			goto restart;
 		}
 

examples/common/entry/entry.h

@@ -370,6 +370,9 @@ namespace entry
 	///
 	int runApp(AppI* _app, int _argc, const char* const* _argv);
 
+	///
+	void setRestartArgs(const char* _args);
+
 } // namespace entry
 
 #endif // ENTRY_H_HEADER_GUARD

examples/common/example-glue.cpp

@@ -130,6 +130,40 @@ static void resourceBar(const char* _name, const char* _tooltip, uint32_t _num,
 
 static bool s_showStats = false;
 
+static const char* getRendererArg(bgfx::RendererType::Enum _type)
+{
+	switch (_type)
+	{
+	case bgfx::RendererType::Direct3D11: return "--d3d11";
+	case bgfx::RendererType::Direct3D12: return "--d3d12";
+	case bgfx::RendererType::Metal:      return "--mtl";
+	case bgfx::RendererType::OpenGL:     return "--gl";
+	case bgfx::RendererType::Vulkan:     return "--vk";
+	case bgfx::RendererType::WebGPU:     return "--wgpu";
+	case bgfx::RendererType::Noop:       return "--noop";
+	default: break;
+	}
+
+	return "";
+}
+
+static const char* getPciIdArg(uint16_t _pciId)
+{
+	switch (_pciId)
+	{
+	case BGFX_PCI_ID_SOFTWARE_RASTERIZER: return "--sw";
+	case BGFX_PCI_ID_AMD:                 return "--amd";
+	case BGFX_PCI_ID_APPLE:               return "--apple";
+	case BGFX_PCI_ID_ARM:                 return "--arm";
+	case BGFX_PCI_ID_INTEL:               return "--intel";
+	case BGFX_PCI_ID_NVIDIA:              return "--nvidia";
+	case BGFX_PCI_ID_MICROSOFT:           return "--microsoft";
+	default: break;
+	}
+
+	return "";
+}
+
 void showExampleDialog(entry::AppI* _app, const char* _errorText)
 {
 	char temp[1024];
@@ -140,8 +174,8 @@ void showExampleDialog(entry::AppI* _app, const char* _errorText)
 		, ImGuiCond_FirstUseEver
 		);
 	ImGui::SetNextWindowSize(
-		  ImVec2(300.0f, 210.0f)
+		  ImVec2(300.0f, 0.0f)
-		, ImGuiCond_FirstUseEver
+		, ImGuiCond_Always
 		);
 
 	ImGui::Begin(temp);
@@ -247,43 +281,72 @@ void showExampleDialog(entry::AppI* _app, const char* _errorText)
 		ImGui::PopStyleVar();
 	}
 
-#if 0
+	char rendererHeader[64];
+	bx::snprintf(rendererHeader, BX_COUNTOF(rendererHeader), "Renderer: %s", bgfx::getRendererName(bgfx::getRendererType() ) );
+
+	if (ImGui::CollapsingHeader(rendererHeader) )
 	{
 		bgfx::RendererType::Enum supportedRenderers[bgfx::RendererType::Count];
-		uint8_t num = bgfx::getSupportedRenderers(BX_COUNTOF(supportedRenderers), supportedRenderers);
+		const uint8_t num = bgfx::getSupportedRenderers(BX_COUNTOF(supportedRenderers), supportedRenderers);
 
 		const bgfx::Caps* caps = bgfx::getCaps();
 
 		const char* items[bgfx::RendererType::Count];
 
+		uint8_t filteredNum = 0;
+		bgfx::RendererType::Enum filteredRenderers[bgfx::RendererType::Count];
 		int32_t current = 0;
 		for (uint8_t ii = 0; ii < num; ++ii)
 		{
-			items[ii] = bgfx::getRendererName(supportedRenderers[ii]);
+			if (bgfx::RendererType::Noop == supportedRenderers[ii])
+			{
+				continue;
+			}
+
+			filteredRenderers[filteredNum] = supportedRenderers[ii];
+			items[filteredNum] = bgfx::getRendererName(supportedRenderers[ii]);
 			if (supportedRenderers[ii] == caps->rendererType)
 			{
-				current = ii;
+				current = filteredNum;
 			}
+			++filteredNum;
 		}
 
-		if (ImGui::Combo("Renderer", &current, items, num) )
+		const float labelWidth = ImGui::CalcTextSize("Renderer ").x + 10.0f;
+
+		const char* newRendererArg = NULL;
+		const char* newPciIdArg    = NULL;
+
+		ImGui::TextUnformatted("Renderer"); ImGui::SameLine(labelWidth);
+		ImGui::PushItemWidth(-1);
+		if (ImGui::Combo("##Renderer", &current, items, filteredNum) )
 		{
-			cmdExec("app restart");
+			newRendererArg = getRendererArg(filteredRenderers[current]);
 		}
 
-		num = caps->numGPUs;
+		const uint8_t numGPUs = caps->numGPUs;
-		if (0 != num)
+		ImGui::BeginDisabled(0 == numGPUs);
 		{
+			static char unknownVendor[BX_COUNTOF(bgfx::Caps::gpu)][16];
 			current = 0;
-			for (uint8_t ii = 0; ii < num; ++ii)
+			for (uint8_t ii = 0; ii < numGPUs; ++ii)
 			{
 				const bgfx::Caps::GPU& gpu = caps->gpu[ii];
 
-				items[ii] = gpu.vendorId == BGFX_PCI_ID_AMD    ? "AMD"
+				switch (gpu.vendorId)
-						  : gpu.vendorId == BGFX_PCI_ID_INTEL  ? "Intel"
+				{
-						  : gpu.vendorId == BGFX_PCI_ID_NVIDIA ? "nVidia"
+				case BGFX_PCI_ID_AMD:                 items[ii] = "AMD";                 break;
-						  : "Unknown?"
+				case BGFX_PCI_ID_APPLE:               items[ii] = "Apple";               break;
-						  ;
+				case BGFX_PCI_ID_INTEL:               items[ii] = "Intel";               break;
+				case BGFX_PCI_ID_NVIDIA:              items[ii] = "nVidia";              break;
+				case BGFX_PCI_ID_MICROSOFT:           items[ii] = "Microsoft";           break;
+				case BGFX_PCI_ID_ARM:                 items[ii] = "ARM";                 break;
+				case BGFX_PCI_ID_SOFTWARE_RASTERIZER: items[ii] = "Software Rasterizer"; break;
+				default:
+					bx::snprintf(unknownVendor[ii], BX_COUNTOF(unknownVendor[ii]), "0x%04x", gpu.vendorId);
+					items[ii] = unknownVendor[ii];
+					break;
+				}
 
 				if (caps->vendorId == gpu.vendorId
 				&&  caps->deviceId == gpu.deviceId)
@@ -292,15 +355,31 @@ void showExampleDialog(entry::AppI* _app, const char* _errorText)
 				}
 			}
 
-			if (ImGui::Combo("GPU", &current, items, num) )
+			ImGui::TextUnformatted("GPU"); ImGui::SameLine(labelWidth);
+			if (ImGui::Combo("##GPU", &current, items, numGPUs) )
 			{
-				cmdExec("app restart");
+				newPciIdArg = getPciIdArg(caps->gpu[current].vendorId);
 			}
 		}
+		ImGui::EndDisabled();
+
+		ImGui::PopItemWidth();
+
+		if (NULL != newRendererArg
+		||  NULL != newPciIdArg)
+		{
+			const char* rendererArg = NULL != newRendererArg ? newRendererArg : getRendererArg(caps->rendererType);
+			const char* pciIdArg    = NULL != newPciIdArg    ? newPciIdArg    : getPciIdArg(caps->vendorId);
+
+			char args[64];
+			bx::snprintf(args, BX_COUNTOF(args), "%s %s", rendererArg, pciIdArg);
+
+			entry::setRestartArgs(args);
+			cmdExec("app restart");
+		}
+
+		ImGui::Separator();
 	}
-#else
-	ImGui::Text("Renderer: %s", bgfx::getRendererName(bgfx::getRendererType()));
-#endif // 0
 
 	const bgfx::Stats* stats = bgfx::getStats();
 	const double toMsCpu = 1000.0/stats->cpuTimerFreq;

src/renderer_d3d11.cpp

@@ -1742,6 +1742,7 @@ namespace bgfx { namespace d3d11
 			m_agsDll = NULL;
 
 			m_deviceCtx->ClearState();
+			m_deviceCtx->Flush();
 
 			invalidateCache();