Merge branch 'master' into TemporaryHackishBranch

Core/Config.cpp

@@ -31,14 +31,16 @@
 #include "net/url.h"
 
 #include "Common/CPUDetect.h"
-#include "Common/KeyMap.h"
 #include "Common/FileUtil.h"
-#include "Common/StringUtils.h"
+#include "Common/KeyMap.h"
 #include "Common/LogManager.h"
+#include "Common/OSVersion.h"
+#include "Common/StringUtils.h"
+#include "Common/Vulkan/VulkanLoader.h"
 #include "Core/Config.h"
 #include "Core/Loaders.h"
+#include "Core/HLE/sceUtility.h"
 #include "GPU/Common/FramebufferCommon.h"
-#include "HLE/sceUtility.h"
 
 // TODO: Find a better place for this.
 http::Downloader g_DownloadManager;
@@ -380,6 +382,7 @@ static ConfigSetting generalSettings[] = {
 	ConfigSetting("LastRemoteISOServer", &g_Config.sLastRemoteISOServer, ""),
 	ConfigSetting("LastRemoteISOPort", &g_Config.iLastRemoteISOPort, 0),
 	ConfigSetting("RemoteISOManualConfig", &g_Config.bRemoteISOManual, false),
+	ConfigSetting("RemoteShareOnStartup", &g_Config.bRemoteShareOnStartup, false),
 	ConfigSetting("RemoteISOSubdir", &g_Config.sRemoteISOSubdir, "/"),
 
 #ifdef __ANDROID__
@@ -480,13 +483,33 @@ static int DefaultAndroidHwScale() {
 #endif
 }
 
+static int DefaultGPUBackend() {
+#if PPSSPP_PLATFORM(WINDOWS) || PPSSPP_PLATFORM(ANDROID)
+	// Where supported, let's use Vulkan.
+	if (VulkanMayBeAvailable()) {
+		return GPU_BACKEND_VULKAN;
+	}
+#endif
+#if PPSSPP_PLATFORM(WINDOWS)
+	// If no Vulkan, use Direct3D 11 on Windows 8+ (most importantly 10.)
+	if (DoesVersionMatchWindows(6, 2, 0, 0, true)) {
+		return GPU_BACKEND_DIRECT3D11;
+	}
+#endif
+	return GPU_BACKEND_OPENGL;
+}
+
+static bool DefaultVertexCache() {
+	return DefaultGPUBackend() == GPU_BACKEND_OPENGL;
+}
+
 static ConfigSetting graphicsSettings[] = {
 	ConfigSetting("EnableCardboard", &g_Config.bEnableCardboard, false, true, true),
 	ConfigSetting("CardboardScreenSize", &g_Config.iCardboardScreenSize, 50, true, true),
 	ConfigSetting("CardboardXShift", &g_Config.iCardboardXShift, 0, true, true),
 	ConfigSetting("CardboardYShift", &g_Config.iCardboardXShift, 0, true, true),
 	ConfigSetting("ShowFPSCounter", &g_Config.iShowFPSCounter, 0, true, true),
-	ReportedConfigSetting("GPUBackend", &g_Config.iGPUBackend, 0),
+	ReportedConfigSetting("GraphicsBackend", &g_Config.iGPUBackend, &DefaultGPUBackend),
 	ReportedConfigSetting("RenderingMode", &g_Config.iRenderingMode, &DefaultRenderingMode, true, true),
 	ConfigSetting("SoftwareRenderer", &g_Config.bSoftwareRendering, false, true, true),
 	ReportedConfigSetting("HardwareTransform", &g_Config.bHardwareTransform, true, true, true),
@@ -512,7 +535,7 @@ static ConfigSetting graphicsSettings[] = {
 #else
 	ConfigSetting("AnisotropyLevel", &g_Config.iAnisotropyLevel, 4, true, true),
 #endif
-	ReportedConfigSetting("VertexCache", &g_Config.bVertexCache, false, true, true),
+	ReportedConfigSetting("VertexDecCache", &g_Config.bVertexCache, &DefaultVertexCache, true, true),
 	ReportedConfigSetting("TextureBackoffCache", &g_Config.bTextureBackoffCache, false, true, true),
 	ReportedConfigSetting("TextureSecondaryCache", &g_Config.bTextureSecondaryCache, false, true, true),
 	ReportedConfigSetting("VertexDecJit", &g_Config.bVertexDecoderJit, &DefaultCodeGen, false),

Core/Config.h

@@ -148,6 +148,7 @@ public:
 	std::string sLastRemoteISOServer;
 	int iLastRemoteISOPort;
 	bool bRemoteISOManual;
+	bool bRemoteShareOnStartup;
 	std::string sRemoteISOSubdir;
 	bool bMemStickInserted;
 

UI/DisplayLayoutScreen.cpp

@@ -81,20 +81,51 @@ bool DisplayLayoutScreen::touch(const TouchInput &touch) {
 		if (mode == 0) {
 			const Bounds &bounds = picked_->GetBounds();
 
-			int minTouchX = screen_bounds.w / 4;
-			int maxTouchX = screen_bounds.w - minTouchX;
+			int limitX = g_Config.fSmallDisplayZoomLevel * 120;
+			int limitY = g_Config.fSmallDisplayZoomLevel * 68;
 
-			int minTouchY = screen_bounds.h / 4;
-			int maxTouchY = screen_bounds.h - minTouchY;
+			const int quarterResX = local_dp_xres / 4;
+			const int quarterResY = local_dp_yres / 4;
+
+			if (bRotated) {
+				//swap X/Y limit for rotated display
+				int limitTemp = limitX;
+				limitX = limitY;
+				limitY = limitTemp;
+			}
+
+			// Check where each edge of the screen is
+			const int windowLeftEdge = quarterResX;
+			const int windowRightEdge = windowLeftEdge * 3;
+			const int windowUpperEdge = quarterResY;
+			const int windowLowerEdge = windowUpperEdge * 3;
+			// And stick display when close to any edge
+			stickToEdgeX = false; stickToEdgeY = false;
+			if (touchX > windowLeftEdge - 8 + limitX && touchX < windowLeftEdge + 8 + limitX) { touchX = windowLeftEdge + limitX; stickToEdgeX = true; }
+			if (touchX > windowRightEdge - 8 - limitX && touchX < windowRightEdge + 8 - limitX) { touchX = windowRightEdge - limitX; stickToEdgeX = true; }
+			if (touchY > windowUpperEdge - 8 + limitY && touchY < windowUpperEdge + 8 + limitY) { touchY = windowUpperEdge + limitY; stickToEdgeY = true; }
+			if (touchY > windowLowerEdge - 8 - limitY && touchY < windowLowerEdge + 8 - limitY) { touchY = windowLowerEdge - limitY; stickToEdgeY = true; }
+
+			const int minX = local_dp_xres / 2;
+			const int maxX = local_dp_xres + minX;
+			const int minY = local_dp_yres / 2;
+			const int maxY = local_dp_yres + minY;
+			// Display visualization disappear outside of those bounds, so we have to limit
+			if (touchX < -minX) touchX = -minX;
+			if (touchX >  maxX) touchX =  maxX;
+			if (touchY < -minY) touchY = -minY;
+			if (touchY >  maxY) touchY =  maxY;
+
+			// Limit small display on much larger output a bit differently
+			if (quarterResX > limitX) limitX = quarterResX;
+			if (quarterResY > limitY) limitY = quarterResY;
 
 			int newX = bounds.centerX(), newY = bounds.centerY();
-			// we have to handle x and y separately since even if x is blocked, y may not be.
-			if (touchX > minTouchX && touchX < maxTouchX) {
-				// if the leftmost point of the control is ahead of the margin,
-				// move it. Otherwise, don't.
+			// Allow moving zoomed in display freely as long as at least noticeable portion of the screen is occupied
+			if (touchX > minX - limitX - 10 && touchX < minX + limitX + 10) {
 				newX = touchX;
 			}
-			if (touchY > minTouchY && touchY < maxTouchY) {
+			if (touchY > minY - limitY - 10 && touchY < minY + limitY + 10) {
 				newY = touchY;
 			}
 			picked_->ReplaceLayoutParams(new UI::AnchorLayoutParams(newX, newY, NONE, NONE, true));
@@ -106,8 +137,9 @@ bool DisplayLayoutScreen::touch(const TouchInput &touch) {
 
 			float movementScale = 0.5f;
 			float newScale = startScale_ + diffY * movementScale;
-			if (newScale > 100.0f) newScale = 100.0f;
-			if (newScale < 1.0f) newScale = 1.0f;
+			// Desired scale * 8.0 since the visualization is tiny size and multiplied by 8.
+			if (newScale > 80.0f) newScale = 80.0f;
+			if (newScale < 8.0f) newScale = 8.0f;
 			picked_->SetScale(newScale);
 			scaleUpdate_ = picked_->GetScale();
 			g_Config.fSmallDisplayZoomLevel = scaleUpdate_ / 8.0f;
@@ -140,8 +172,10 @@ void DisplayLayoutScreen::onFinish(DialogResult reason) {
 }
 
 UI::EventReturn DisplayLayoutScreen::OnCenter(UI::EventParams &e) {
-	g_Config.fSmallDisplayOffsetX = 0.5f;
-	g_Config.fSmallDisplayOffsetY = 0.5f;
+	if (!stickToEdgeX || (stickToEdgeX && stickToEdgeY))
+		g_Config.fSmallDisplayOffsetX = 0.5f;
+	if (!stickToEdgeY || (stickToEdgeX && stickToEdgeY))
+		g_Config.fSmallDisplayOffsetY = 0.5f;
 	RecreateViews();
 	return UI::EVENT_DONE;
 };
@@ -222,7 +256,7 @@ void DisplayLayoutScreen::CreateViews() {
 	rotation_ = new PopupMultiChoice(&g_Config.iInternalScreenRotation, gr->T("Rotation"), displayRotation, 1, ARRAY_SIZE(displayRotation), co->GetName(), screenManager(), new AnchorLayoutParams(400, WRAP_CONTENT, previewWidth - 200.0f, 10, NONE, local_dp_yres - 64 - 10));
 	rotation_->SetEnabledPtr(&displayRotEnable_);
 	displayRotEnable_ = (g_Config.iRenderingMode != FB_NON_BUFFERED_MODE);
-	bool bRotated = false;
+	bRotated = false;
 	if (displayRotEnable_ && (g_Config.iInternalScreenRotation == ROTATION_LOCKED_VERTICAL || g_Config.iInternalScreenRotation == ROTATION_LOCKED_VERTICAL180)) {
 		bRotated = true;
 	}

UI/DisplayLayoutScreen.h

@@ -44,6 +44,9 @@ private:
 	UI::PopupMultiChoice *zoom_;
 	UI::PopupMultiChoice *rotation_;
 	bool displayRotEnable_;
+	bool bRotated;
+	bool stickToEdgeX;
+	bool stickToEdgeY;
 	// Touch down state for drag to resize etc
 	float startX_;
 	float startY_;

UI/NativeApp.cpp

@@ -92,6 +92,7 @@
 #include "UI/HostTypes.h"
 #include "UI/OnScreenDisplay.h"
 #include "UI/MiscScreens.h"
+#include "UI/RemoteISOScreen.h"
 #include "UI/TiltEventProcessor.h"
 #include "UI/BackgroundAudio.h"
 #include "UI/TextureUtil.h"
@@ -544,6 +545,10 @@ void NativeInit(int argc, const char *argv[], const char *savegame_dir, const ch
 		screenManager->switchScreen(new LogoScreen());
 	}
 
+	if (g_Config.bRemoteShareOnStartup) {
+		StartRemoteISOSharing();
+	}
+
 	std::string sysName = System_GetProperty(SYSPROP_NAME);
 	isOuya = KeyMap::IsOuya(sysName);
 
@@ -1095,6 +1100,10 @@ void NativeResized() {
 	// NativeResized can come from any thread so we just set a flag, then process it later.
 	if (g_graphicsInited) {
 		resized = true;
+		if (uiContext) {
+			// Still have to update bounds to avoid problems in display layout and touch controls layout screens
+			uiContext->SetBounds(Bounds(0, 0, dp_xres, dp_yres));
+		}
 	} else {
 		ILOG("NativeResized ignored, not initialized");
 	}

UI/RemoteISOScreen.cpp

@@ -186,6 +186,20 @@ static void ExecuteServer() {
 	UpdateStatus(ServerStatus::STOPPED);
 }
 
+bool StartRemoteISOSharing() {
+	std::lock_guard<std::mutex> guard(serverStatusLock);
+
+	if (serverStatus != ServerStatus::STOPPED) {
+		return false;
+	}
+
+	serverStatus = ServerStatus::STARTING;
+	serverThread = new std::thread(&ExecuteServer);
+	serverThread->detach();
+
+	return true;
+}
+
 static bool FindServer(std::string &resultHost, int &resultPort) {
 	http::Client http;
 	Buffer result;
@@ -412,16 +426,10 @@ void RemoteISOScreen::CreateViews() {
 }
 
 UI::EventReturn RemoteISOScreen::HandleStartServer(UI::EventParams &e) {
-	std::lock_guard<std::mutex> guard(serverStatusLock);
-
-	if (serverStatus != ServerStatus::STOPPED) {
+	if (!StartRemoteISOSharing()) {
 		return EVENT_SKIPPED;
 	}
 
-	serverStatus = ServerStatus::STARTING;
-	serverThread = new std::thread(&ExecuteServer);
-	serverThread->detach();
-
 	return EVENT_DONE;
 }
 
@@ -651,7 +659,7 @@ void RemoteISOBrowseScreen::CreateViews() {
 }
 
 RemoteISOSettingsScreen::RemoteISOSettingsScreen() {
-	serverRunning_ = RetrieveStatus() != ServerStatus::STOPPED;;
+	serverRunning_ = RetrieveStatus() != ServerStatus::STOPPED;
 }
 
 void RemoteISOSettingsScreen::update() {
@@ -674,7 +682,8 @@ void RemoteISOSettingsScreen::CreateViews() {
 	remoteisoSettingsScroll->Add(remoteisoSettings);
 
 	remoteisoSettings->Add(new ItemHeader(ri->T("Remote disc streaming")));
-	remoteisoSettings->Add(new CheckBox(&g_Config.bRemoteISOManual, ri->T("Manual Mode Client", "Manual Mode Client")));
+	remoteisoSettings->Add(new CheckBox(&g_Config.bRemoteShareOnStartup, ri->T("Share on PPSSPP startup")));
+	remoteisoSettings->Add(new CheckBox(&g_Config.bRemoteISOManual, ri->T("Manual Mode Client", "Manually configure client")));
 #if !defined(MOBILE_DEVICE)
 	PopupTextInputChoice *remoteServer = remoteisoSettings->Add(new PopupTextInputChoice(&g_Config.sLastRemoteISOServer, ri->T("Remote Server"), "", 255, screenManager()));
 #else

UI/RemoteISOScreen.h

@@ -25,6 +25,8 @@
 #include "UI/MiscScreens.h"
 #include "UI/MainScreen.h"
 
+bool StartRemoteISOSharing();
+
 class RemoteISOScreen : public UIScreenWithBackground {
 public:
 	RemoteISOScreen();