Fixed conflicts

.gitignore

@@ -28,6 +28,7 @@
 *.unsuccessfulbuild
 *.res
 *.dump
+*.wav
 
 /libs
 /ipch
@@ -52,3 +53,6 @@ rpcs3/git-version.h
 !/bin/dev_hdd0/game/
 /bin/dev_hdd0/game/*
 !/bin/dev_hdd0/game/TEST12345/
+
+# Ignore other system generated files
+bin/dev_hdd0/home/00000001/trophy

Utilities/Thread.cpp

@@ -52,11 +52,12 @@ void ThreadBase::Start()
 		});
 }
 
-void ThreadBase::Stop(bool wait)
+void ThreadBase::Stop(bool wait, bool send_destroy)
 {
 	std::lock_guard<std::mutex> lock(m_main_mutex);
 
-	m_destroy = true;
+	if (send_destroy)
+		m_destroy = true;
 
 	if(!m_executor)
 		return;

Utilities/Thread.h

@@ -41,7 +41,7 @@ protected:
 
 public:
 	void Start();
-	void Stop(bool wait = true);
+	void Stop(bool wait = true, bool send_destroy = true);
 
 	bool Join() const;
 	bool IsAlive() const;

Utilities/Timer.h

@@ -1,38 +1,52 @@
 #pragma once
 
 #include <chrono>
-using namespace std::chrono;
 
 class Timer
 {
 private:
-	bool stopped;
+	bool m_stopped;
-	high_resolution_clock::time_point start;
+	std::chrono::high_resolution_clock::time_point m_start;
-	high_resolution_clock::time_point end;
+	std::chrono::high_resolution_clock::time_point m_end;
 
 public:
-	Timer() : stopped(false)
+	Timer() : m_stopped(false)
 	{
 	}
 
 	void Start()
 	{
-		stopped = false;
+		m_stopped = false;
-        start = high_resolution_clock::now();
+		m_start = std::chrono::high_resolution_clock::now();
 	}
 
 	void Stop()
 	{
-		stopped = true;
+		m_stopped = true;
-        end = high_resolution_clock::now();
+		m_end = std::chrono::high_resolution_clock::now();
 	}
 
-	double GetElapsedTimeInSec(){return GetElapsedTimeInMicroSec() / 1000000.0;}
+	double GetElapsedTimeInSec() const
-    double GetElapsedTimeInMilliSec(){return GetElapsedTimeInMicroSec() / 1000.0;}
-    double GetElapsedTimeInMicroSec()
 	{
-		if (!stopped)
+		return GetElapsedTimeInMicroSec() / 1000000.0;
-            end = high_resolution_clock::now();
+	}
-		return duration_cast<microseconds>(end - start).count();
+
+	double GetElapsedTimeInMilliSec() const
+	{
+		return GetElapsedTimeInMicroSec() / 1000.0;
+	}
+
+	double GetElapsedTimeInMicroSec() const
+	{
+		std::chrono::high_resolution_clock::time_point now = m_stopped ? m_end : std::chrono::high_resolution_clock::now();
+
+		return std::chrono::duration_cast<std::chrono::microseconds>(now - m_start).count();
+	}
+
+	double GetElapsedTimeInNanoSec() const
+	{
+		std::chrono::high_resolution_clock::time_point now = m_stopped ? m_end : std::chrono::high_resolution_clock::now();
+
+		return std::chrono::duration_cast<std::chrono::nanoseconds>(now - m_start).count();
 	}
 };

bin/dev_hdd0/home/00000001/localusername

@@ -0,0 +1 @@
+User

bin/dev_hdd1/.gitignore

@@ -1,4 +1,6 @@
 # Ignore everything in this directory
 *
 # Except this file
-!.gitignore
+!.gitignore
+!cache
+!cache/README.txt

bin/dev_hdd1/cache/README.txt

@@ -0,0 +1 @@
+every Folder in this directory gets cleared when  cellSysCacheClear() is called, so don't store important data here

rpcs3.sln

@@ -1,7 +1,5 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
+# Visual Studio 2012
-VisualStudioVersion = 12.0.30110.0
-MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rpcs3", "rpcs3\rpcs3.vcxproj", "{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}"
 	ProjectSection(ProjectDependencies) = postProject
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23} = {CD478F02-7550-58A5-E085-CE4BC0C0AD23}
@@ -10,6 +8,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rpcs3", "rpcs3\rpcs3.vcxpro
 		{23E1C437-A951-5943-8639-A17F3CF2E606} = {23E1C437-A951-5943-8639-A17F3CF2E606}
 		{22B14659-C5B6-B775-868D-A49198FEAD4A} = {22B14659-C5B6-B775-868D-A49198FEAD4A}
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2} = {9ED1866B-D4AE-3440-24E4-7A9475B163B2}
+		{6EDC3B79-D217-F11A-406F-F11D856493F9} = {6EDC3B79-D217-F11A-406F-F11D856493F9}
 		{3111D679-7796-23C4-BA0C-271F1145DA24} = {3111D679-7796-23C4-BA0C-271F1145DA24}
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA} = {AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774} = {FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}
@@ -123,10 +122,6 @@ Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
 		Debug|x64 = Debug|x64
-		DLL Debug|Win32 = DLL Debug|Win32
-		DLL Debug|x64 = DLL Debug|x64
-		DLL Release|Win32 = DLL Release|Win32
-		DLL Release|x64 = DLL Release|x64
 		Release|Win32 = Release|Win32
 		Release|x64 = Release|x64
 	EndGlobalSection
@@ -135,14 +130,6 @@ Global
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug|Win32.Build.0 = Debug|Win32
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug|x64.ActiveCfg = Debug|x64
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Debug|x64.Build.0 = Debug|x64
-		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.DLL Debug|Win32.ActiveCfg = Debug|Win32
-		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.DLL Debug|Win32.Build.0 = Debug|Win32
-		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.DLL Debug|x64.ActiveCfg = Debug|x64
-		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.DLL Debug|x64.Build.0 = Debug|x64
-		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.DLL Release|Win32.ActiveCfg = Release|Win32
-		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.DLL Release|Win32.Build.0 = Release|Win32
-		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.DLL Release|x64.ActiveCfg = Release|x64
-		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.DLL Release|x64.Build.0 = Release|x64
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Release|Win32.ActiveCfg = Release|Win32
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Release|Win32.Build.0 = Release|Win32
 		{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}.Release|x64.ActiveCfg = Release|x64
@@ -151,14 +138,6 @@ Global
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug|Win32.Build.0 = Debug|Win32
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug|x64.ActiveCfg = Debug|x64
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Debug|x64.Build.0 = Debug|x64
-		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.DLL Release|x64.Build.0 = DLL Release|x64
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Release|Win32.ActiveCfg = Release|Win32
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Release|Win32.Build.0 = Release|Win32
 		{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}.Release|x64.ActiveCfg = Release|x64
@@ -167,14 +146,6 @@ Global
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug|Win32.Build.0 = Debug|Win32
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug|x64.ActiveCfg = Debug|x64
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Debug|x64.Build.0 = Debug|x64
-		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.DLL Release|x64.Build.0 = DLL Release|x64
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Release|Win32.ActiveCfg = Release|Win32
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Release|Win32.Build.0 = Release|Win32
 		{7047EE97-7F80-A70D-6147-BC11102DB6F4}.Release|x64.ActiveCfg = Release|x64
@@ -183,14 +154,6 @@ Global
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug|Win32.Build.0 = Debug|Win32
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug|x64.ActiveCfg = Debug|x64
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Debug|x64.Build.0 = Debug|x64
-		{3111D679-7796-23C4-BA0C-271F1145DA24}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{3111D679-7796-23C4-BA0C-271F1145DA24}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{3111D679-7796-23C4-BA0C-271F1145DA24}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{3111D679-7796-23C4-BA0C-271F1145DA24}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{3111D679-7796-23C4-BA0C-271F1145DA24}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{3111D679-7796-23C4-BA0C-271F1145DA24}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{3111D679-7796-23C4-BA0C-271F1145DA24}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{3111D679-7796-23C4-BA0C-271F1145DA24}.DLL Release|x64.Build.0 = DLL Release|x64
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Release|Win32.ActiveCfg = Release|Win32
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Release|Win32.Build.0 = Release|Win32
 		{3111D679-7796-23C4-BA0C-271F1145DA24}.Release|x64.ActiveCfg = Release|x64
@@ -199,14 +162,6 @@ Global
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug|Win32.Build.0 = Debug|Win32
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug|x64.ActiveCfg = Debug|x64
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Debug|x64.Build.0 = Debug|x64
-		{067D9406-2A93-DACA-9449-93A2D356357D}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{067D9406-2A93-DACA-9449-93A2D356357D}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{067D9406-2A93-DACA-9449-93A2D356357D}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{067D9406-2A93-DACA-9449-93A2D356357D}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{067D9406-2A93-DACA-9449-93A2D356357D}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{067D9406-2A93-DACA-9449-93A2D356357D}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{067D9406-2A93-DACA-9449-93A2D356357D}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{067D9406-2A93-DACA-9449-93A2D356357D}.DLL Release|x64.Build.0 = DLL Release|x64
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Release|Win32.ActiveCfg = Release|Win32
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Release|Win32.Build.0 = Release|Win32
 		{067D9406-2A93-DACA-9449-93A2D356357D}.Release|x64.ActiveCfg = Release|x64
@@ -215,14 +170,6 @@ Global
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug|Win32.Build.0 = Debug|Win32
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug|x64.ActiveCfg = Debug|x64
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Debug|x64.Build.0 = Debug|x64
-		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.DLL Release|x64.Build.0 = DLL Release|x64
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Release|Win32.ActiveCfg = Release|Win32
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Release|Win32.Build.0 = Release|Win32
 		{9ED1866B-D4AE-3440-24E4-7A9475B163B2}.Release|x64.ActiveCfg = Release|x64
@@ -231,14 +178,6 @@ Global
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug|Win32.Build.0 = Debug|Win32
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug|x64.ActiveCfg = Debug|x64
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Debug|x64.Build.0 = Debug|x64
-		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.DLL Release|x64.Build.0 = DLL Release|x64
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Release|Win32.ActiveCfg = Release|Win32
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Release|Win32.Build.0 = Release|Win32
 		{99C9EB95-DB4C-1996-490E-5212EFBF07C3}.Release|x64.ActiveCfg = Release|x64
@@ -247,14 +186,6 @@ Global
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug|Win32.Build.0 = Debug|Win32
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug|x64.ActiveCfg = Debug|x64
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Debug|x64.Build.0 = Debug|x64
-		{6EDC3B79-D217-F11A-406F-F11D856493F9}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{6EDC3B79-D217-F11A-406F-F11D856493F9}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{6EDC3B79-D217-F11A-406F-F11D856493F9}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{6EDC3B79-D217-F11A-406F-F11D856493F9}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{6EDC3B79-D217-F11A-406F-F11D856493F9}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{6EDC3B79-D217-F11A-406F-F11D856493F9}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{6EDC3B79-D217-F11A-406F-F11D856493F9}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{6EDC3B79-D217-F11A-406F-F11D856493F9}.DLL Release|x64.Build.0 = DLL Release|x64
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Release|Win32.ActiveCfg = Release|Win32
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Release|Win32.Build.0 = Release|Win32
 		{6EDC3B79-D217-F11A-406F-F11D856493F9}.Release|x64.ActiveCfg = Release|x64
@@ -263,14 +194,6 @@ Global
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug|Win32.Build.0 = Debug|Win32
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug|x64.ActiveCfg = Debug|x64
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Debug|x64.Build.0 = Debug|x64
-		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.DLL Release|x64.Build.0 = DLL Release|x64
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Release|Win32.ActiveCfg = Release|Win32
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Release|Win32.Build.0 = Release|Win32
 		{A9AC9CF5-8E6C-0BA2-0769-6E42EDB88E25}.Release|x64.ActiveCfg = Release|x64
@@ -279,14 +202,6 @@ Global
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug|Win32.Build.0 = Debug|Win32
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug|x64.ActiveCfg = Debug|x64
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Debug|x64.Build.0 = Debug|x64
-		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.DLL Release|x64.Build.0 = DLL Release|x64
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Release|Win32.ActiveCfg = Release|Win32
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Release|Win32.Build.0 = Release|Win32
 		{CD478F02-7550-58A5-E085-CE4BC0C0AD23}.Release|x64.ActiveCfg = Release|x64
@@ -295,14 +210,6 @@ Global
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug|Win32.Build.0 = Debug|Win32
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug|x64.ActiveCfg = Debug|x64
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Debug|x64.Build.0 = Debug|x64
-		{22B14659-C5B6-B775-868D-A49198FEAD4A}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{22B14659-C5B6-B775-868D-A49198FEAD4A}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{22B14659-C5B6-B775-868D-A49198FEAD4A}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{22B14659-C5B6-B775-868D-A49198FEAD4A}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{22B14659-C5B6-B775-868D-A49198FEAD4A}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{22B14659-C5B6-B775-868D-A49198FEAD4A}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{22B14659-C5B6-B775-868D-A49198FEAD4A}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{22B14659-C5B6-B775-868D-A49198FEAD4A}.DLL Release|x64.Build.0 = DLL Release|x64
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Release|Win32.ActiveCfg = Release|Win32
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Release|Win32.Build.0 = Release|Win32
 		{22B14659-C5B6-B775-868D-A49198FEAD4A}.Release|x64.ActiveCfg = Release|x64
@@ -311,14 +218,6 @@ Global
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug|Win32.Build.0 = Debug|Win32
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug|x64.ActiveCfg = Debug|x64
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Debug|x64.Build.0 = Debug|x64
-		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.DLL Release|x64.Build.0 = DLL Release|x64
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Release|Win32.ActiveCfg = Release|Win32
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Release|Win32.Build.0 = Release|Win32
 		{FAF0CB93-F7CE-A6B8-8342-19CE99BAF774}.Release|x64.ActiveCfg = Release|x64
@@ -327,14 +226,6 @@ Global
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug|Win32.Build.0 = Debug|Win32
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug|x64.ActiveCfg = Debug|x64
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Debug|x64.Build.0 = Debug|x64
-		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.DLL Release|x64.Build.0 = DLL Release|x64
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Release|Win32.ActiveCfg = Release|Win32
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Release|Win32.Build.0 = Release|Win32
 		{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}.Release|x64.ActiveCfg = Release|x64
@@ -343,14 +234,6 @@ Global
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug|Win32.Build.0 = Debug|Win32
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug|x64.ActiveCfg = Debug|x64
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Debug|x64.Build.0 = Debug|x64
-		{5C363C34-4741-7036-861C-2E2279CF552E}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{5C363C34-4741-7036-861C-2E2279CF552E}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{5C363C34-4741-7036-861C-2E2279CF552E}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{5C363C34-4741-7036-861C-2E2279CF552E}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{5C363C34-4741-7036-861C-2E2279CF552E}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{5C363C34-4741-7036-861C-2E2279CF552E}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{5C363C34-4741-7036-861C-2E2279CF552E}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{5C363C34-4741-7036-861C-2E2279CF552E}.DLL Release|x64.Build.0 = DLL Release|x64
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Release|Win32.ActiveCfg = Release|Win32
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Release|Win32.Build.0 = Release|Win32
 		{5C363C34-4741-7036-861C-2E2279CF552E}.Release|x64.ActiveCfg = Release|x64
@@ -359,14 +242,6 @@ Global
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug|Win32.Build.0 = Debug|Win32
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug|x64.ActiveCfg = Debug|x64
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Debug|x64.Build.0 = Debug|x64
-		{76169FE8-0814-4F36-6409-699EF1A23001}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{76169FE8-0814-4F36-6409-699EF1A23001}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{76169FE8-0814-4F36-6409-699EF1A23001}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{76169FE8-0814-4F36-6409-699EF1A23001}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{76169FE8-0814-4F36-6409-699EF1A23001}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{76169FE8-0814-4F36-6409-699EF1A23001}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{76169FE8-0814-4F36-6409-699EF1A23001}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{76169FE8-0814-4F36-6409-699EF1A23001}.DLL Release|x64.Build.0 = DLL Release|x64
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Release|Win32.ActiveCfg = Release|Win32
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Release|Win32.Build.0 = Release|Win32
 		{76169FE8-0814-4F36-6409-699EF1A23001}.Release|x64.ActiveCfg = Release|x64
@@ -375,14 +250,6 @@ Global
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug|Win32.Build.0 = Debug|Win32
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug|x64.ActiveCfg = Debug|x64
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Debug|x64.Build.0 = Debug|x64
-		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.DLL Release|x64.Build.0 = DLL Release|x64
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Release|Win32.ActiveCfg = Release|Win32
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Release|Win32.Build.0 = Release|Win32
 		{949C6DB8-E638-6EC6-AB31-BCCFD1379E01}.Release|x64.ActiveCfg = Release|x64
@@ -391,14 +258,6 @@ Global
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug|Win32.Build.0 = Debug|Win32
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug|x64.ActiveCfg = Debug|x64
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Debug|x64.Build.0 = Debug|x64
-		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.DLL Release|x64.Build.0 = DLL Release|x64
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Release|Win32.ActiveCfg = Release|Win32
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Release|Win32.Build.0 = Release|Win32
 		{B87216CD-6C64-1DB0-D900-BC6E745C1DF9}.Release|x64.ActiveCfg = Release|x64
@@ -407,14 +266,6 @@ Global
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug|Win32.Build.0 = Debug|Win32
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug|x64.ActiveCfg = Debug|x64
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Debug|x64.Build.0 = Debug|x64
-		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.DLL Release|x64.Build.0 = DLL Release|x64
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Release|Win32.ActiveCfg = Release|Win32
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Release|Win32.Build.0 = Release|Win32
 		{AFF2C68B-B867-DD50-6AC5-74B09D41F8EA}.Release|x64.ActiveCfg = Release|x64
@@ -423,14 +274,6 @@ Global
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug|Win32.Build.0 = Debug|Win32
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug|x64.ActiveCfg = Debug|x64
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Debug|x64.Build.0 = Debug|x64
-		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.DLL Release|x64.Build.0 = DLL Release|x64
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Release|Win32.ActiveCfg = Release|Win32
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Release|Win32.Build.0 = Release|Win32
 		{6FDC76D5-CB44-B9F8-5EF6-C59B020719DF}.Release|x64.ActiveCfg = Release|x64
@@ -439,14 +282,6 @@ Global
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug|Win32.Build.0 = Debug|Win32
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug|x64.ActiveCfg = Debug|x64
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Debug|x64.Build.0 = Debug|x64
-		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.DLL Release|x64.Build.0 = DLL Release|x64
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Release|Win32.ActiveCfg = Release|Win32
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Release|Win32.Build.0 = Release|Win32
 		{8BECCA95-C7D7-CFF8-FDB1-4950E9F8E8E6}.Release|x64.ActiveCfg = Release|x64
@@ -455,14 +290,6 @@ Global
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug|Win32.Build.0 = Debug|Win32
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug|x64.ActiveCfg = Debug|x64
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Debug|x64.Build.0 = Debug|x64
-		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.DLL Release|x64.Build.0 = DLL Release|x64
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Release|Win32.ActiveCfg = Release|Win32
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Release|Win32.Build.0 = Release|Win32
 		{87B42A9C-3F5C-53D7-9017-2B1CAE39457D}.Release|x64.ActiveCfg = Release|x64
@@ -471,14 +298,6 @@ Global
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug|Win32.Build.0 = Debug|Win32
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug|x64.ActiveCfg = Debug|x64
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Debug|x64.Build.0 = Debug|x64
-		{23E1C437-A951-5943-8639-A17F3CF2E606}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{23E1C437-A951-5943-8639-A17F3CF2E606}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{23E1C437-A951-5943-8639-A17F3CF2E606}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{23E1C437-A951-5943-8639-A17F3CF2E606}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{23E1C437-A951-5943-8639-A17F3CF2E606}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{23E1C437-A951-5943-8639-A17F3CF2E606}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{23E1C437-A951-5943-8639-A17F3CF2E606}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{23E1C437-A951-5943-8639-A17F3CF2E606}.DLL Release|x64.Build.0 = DLL Release|x64
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Release|Win32.ActiveCfg = Release|Win32
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Release|Win32.Build.0 = Release|Win32
 		{23E1C437-A951-5943-8639-A17F3CF2E606}.Release|x64.ActiveCfg = Release|x64
@@ -487,14 +306,6 @@ Global
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug|Win32.Build.0 = Debug|Win32
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug|x64.ActiveCfg = Debug|x64
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Debug|x64.Build.0 = Debug|x64
-		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.DLL Debug|Win32.ActiveCfg = DLL Debug|Win32
-		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.DLL Debug|Win32.Build.0 = DLL Debug|Win32
-		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.DLL Debug|x64.ActiveCfg = DLL Debug|x64
-		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.DLL Debug|x64.Build.0 = DLL Debug|x64
-		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.DLL Release|Win32.ActiveCfg = DLL Release|Win32
-		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.DLL Release|Win32.Build.0 = DLL Release|Win32
-		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.DLL Release|x64.ActiveCfg = DLL Release|x64
-		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.DLL Release|x64.Build.0 = DLL Release|x64
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Release|Win32.ActiveCfg = Release|Win32
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Release|Win32.Build.0 = Release|Win32
 		{74827EBD-93DC-5110-BA95-3F2AB029B6B0}.Release|x64.ActiveCfg = Release|x64

rpcs3/Emu/CPU/CPUThread.cpp

@@ -96,21 +96,21 @@ bool CPUThread::Sync()
 
 int CPUThread::ThreadStatus()
 {
-	if (Emu.IsStopped() || IsStopped())
+	if(Emu.IsStopped() || IsStopped() || IsPaused())
 	{
 		return CPUThread_Stopped;
 	}
 
-	if (m_is_step)
+	if(TestDestroy())
-	{
-		return CPUThread_Step;
-	}
-
-	if (TestDestroy() || IsPaused())
 	{
 		return CPUThread_Break;
 	}
 
+	if(m_is_step)
+	{
+		return CPUThread_Step;
+	}
+
 	if (Emu.IsPaused() || Sync())
 	{
 		return CPUThread_Sleeping;
@@ -284,8 +284,10 @@ void CPUThread::ExecOnce()
 #ifndef QT_UI
 	wxGetApp().SendDbgCommand(DID_EXEC_THREAD, this);
 #endif
+	m_status = Running;
 	ThreadBase::Start();
-	ThreadBase::Stop();
+	ThreadBase::Stop(true,false);
+	m_status = Paused;
 #ifndef QT_UI
 	wxGetApp().SendDbgCommand(DID_PAUSE_THREAD, this);
 	wxGetApp().SendDbgCommand(DID_PAUSED_THREAD, this);

rpcs3/Emu/FS/VFS.cpp

@@ -1,6 +1,7 @@
 #include "stdafx.h"
 #include "VFS.h"
 #include "Emu/HDD/HDD.h"
+#include "vfsDeviceLocalFile.h"
 
 int sort_devices(const void* _a, const void* _b)
 {
@@ -22,7 +23,7 @@ void VFS::Mount(const wxString& ps3_path, const wxString& local_path, vfsDevice*
 
 	if(m_devices.GetCount() > 1)
 	{
-		std::qsort(m_devices.GetPtr(), m_devices.GetCount(), sizeof(vfsDevice*), sort_devices);
+		//std::qsort(m_devices.GetPtr(), m_devices.GetCount(), sizeof(vfsDevice*), sort_devices);
 	}
 }
 
@@ -49,37 +50,166 @@ void VFS::UnMountAll()
 	}
 }
 
-vfsStream* VFS::Open(const wxString& ps3_path, vfsOpenMode mode)
+vfsFileBase* VFS::OpenFile(const wxString& ps3_path, vfsOpenMode mode) const
 {
-	vfsDevice* stream = nullptr;
-
 	wxString path;
 	if(vfsDevice* dev = GetDevice(ps3_path, path))
 	{
-		stream = dev->GetNew();
+		if(vfsFileBase* res = dev->GetNewFileStream())
-		stream->Open(path, mode);
+		{
+			res->Open(path, mode);
+			return res;
+		}
 	}
 
-	return stream;
+	return nullptr;
 }
 
-void VFS::Create(const wxString& ps3_path)
+vfsDirBase* VFS::OpenDir(const wxString& ps3_path) const
 {
 	wxString path;
 
 	if(vfsDevice* dev = GetDevice(ps3_path, path))
 	{
-		dev->Create(path);
+		if(vfsDirBase* res = dev->GetNewDirStream())
+		{
+			res->Open(path);
+			return res;
+		}
 	}
+
+	return nullptr;
 }
 
-void VFS::Close(vfsStream*& device)
+bool VFS::CreateFile(const wxString& ps3_path) const
 {
-	delete device;
+	wxString path;
-	device = nullptr;
+	if(vfsDevice* dev = GetDevice(ps3_path, path))
+	{
+		std::shared_ptr<vfsFileBase> res(dev->GetNewFileStream());
+
+		if(res)
+		{
+			return res->Create(path);
+		}
+	}
+
+	return false;
 }
 
-vfsDevice* VFS::GetDevice(const wxString& ps3_path, wxString& path)
+bool VFS::CreateDir(const wxString& ps3_path) const
+{
+	wxString path;
+	if(vfsDevice* dev = GetDevice(ps3_path, path))
+	{
+		std::shared_ptr<vfsDirBase> res(dev->GetNewDirStream());
+
+		if(res)
+		{
+			return res->Create(path);
+		}
+	}
+
+	return false;
+}
+
+bool VFS::RemoveFile(const wxString& ps3_path) const
+{
+	wxString path;
+	if(vfsDevice* dev = GetDevice(ps3_path, path))
+	{
+		std::shared_ptr<vfsFileBase> res(dev->GetNewFileStream());
+
+		if(res)
+		{
+			return res->Remove(path);
+		}
+	}
+
+	return false;
+}
+
+bool VFS::RemoveDir(const wxString& ps3_path) const
+{
+	wxString path;
+	if(vfsDevice* dev = GetDevice(ps3_path, path))
+	{
+		std::shared_ptr<vfsDirBase> res(dev->GetNewDirStream());
+
+		if(res)
+		{
+			return res->Remove(path);
+		}
+	}
+
+	return false;
+}
+
+bool VFS::ExistsFile(const wxString& ps3_path) const
+{
+	wxString path;
+	if(vfsDevice* dev = GetDevice(ps3_path, path))
+	{
+		std::shared_ptr<vfsFileBase> res(dev->GetNewFileStream());
+
+		if(res)
+		{
+			return res->Exists(path);
+		}
+	}
+
+	return false;
+}
+
+bool VFS::ExistsDir(const wxString& ps3_path) const
+{
+	wxString path;
+	if(vfsDevice* dev = GetDevice(ps3_path, path))
+	{
+		std::shared_ptr<vfsDirBase> res(dev->GetNewDirStream());
+
+		if(res)
+		{
+			return res->IsExists(path);
+		}
+	}
+
+	return false;
+}
+
+bool VFS::RenameFile(const wxString& ps3_path_from, const wxString& ps3_path_to) const
+{
+	wxString path;
+	if(vfsDevice* dev = GetDevice(ps3_path_from, path))
+	{
+		std::shared_ptr<vfsFileBase> res(dev->GetNewFileStream());
+
+		if(res)
+		{
+			return res->Rename(path, ps3_path_to);
+		}
+	}
+
+	return false;
+}
+
+bool VFS::RenameDir(const wxString& ps3_path_from, const wxString& ps3_path_to) const
+{
+	wxString path;
+	if(vfsDevice* dev = GetDevice(ps3_path_from, path))
+	{
+		std::shared_ptr<vfsDirBase> res(dev->GetNewDirStream());
+
+		if(res)
+		{
+			return res->Rename(path, ps3_path_to);
+		}
+	}
+
+	return false;
+}
+
+vfsDevice* VFS::GetDevice(const wxString& ps3_path, wxString& path) const
 {
 	u32 max_eq;
 	s32 max_i=-1;
@@ -101,14 +231,18 @@ vfsDevice* VFS::GetDevice(const wxString& ps3_path, wxString& path)
 	return &m_devices[max_i];
 }
 
-vfsDevice* VFS::GetDeviceLocal(const wxString& local_path, wxString& path)
+vfsDevice* VFS::GetDeviceLocal(const wxString& local_path, wxString& path) const
 {
 	u32 max_eq;
 	s32 max_i=-1;
 
+	wxFileName file_path(local_path);
+	file_path.Normalize();
+	wxString mormalized_path = file_path.GetFullPath();
+
 	for(u32 i=0; i<m_devices.GetCount(); ++i)
 	{
-		const u32 eq = m_devices[i].CmpLocalPath(local_path);
+		const u32 eq = m_devices[i].CmpLocalPath(mormalized_path);
 
 		if(max_i < 0 || eq > max_eq)
 		{
@@ -135,11 +269,11 @@ void VFS::Init(const wxString& path)
 		switch(entries[i].device)
 		{
 		case vfsDevice_LocalFile:
-			dev = new vfsLocalFile();
+			dev = new vfsDeviceLocalFile();
 		break;
 
 		case vfsDevice_HDD:
-			dev = new vfsHDD(entries[i].device_path);
+			dev = new vfsDeviceHDD(entries[i].device_path);
 		break;
 
 		default:

rpcs3/Emu/FS/VFS.h

@@ -36,11 +36,19 @@ struct VFS
 	void UnMount(const wxString& ps3_path);
 	void UnMountAll();
 
-	vfsStream* Open(const wxString& ps3_path, vfsOpenMode mode);
+	vfsFileBase* OpenFile(const wxString& ps3_path, vfsOpenMode mode) const;
-	void Create(const wxString& ps3_path);
+	vfsDirBase* OpenDir(const wxString& ps3_path) const;
-	void Close(vfsStream*& device);
+	bool CreateFile(const wxString& ps3_path) const;
-	vfsDevice* GetDevice(const wxString& ps3_path, wxString& path);
+	bool CreateDir(const wxString& ps3_path) const;
-	vfsDevice* GetDeviceLocal(const wxString& local_path, wxString& path);
+	bool RemoveFile(const wxString& ps3_path) const;
+	bool RemoveDir(const wxString& ps3_path) const;
+	bool ExistsFile(const wxString& ps3_path) const;
+	bool ExistsDir(const wxString& ps3_path) const;
+	bool RenameFile(const wxString& ps3_path_from, const wxString& ps3_path_to) const;
+	bool RenameDir(const wxString& ps3_path_from, const wxString& ps3_path_to) const;
+
+	vfsDevice* GetDevice(const wxString& ps3_path, wxString& path) const;
+	vfsDevice* GetDeviceLocal(const wxString& local_path, wxString& path) const;
 
 	void Init(const wxString& path);
 	void SaveLoadDevices(Array<VFSManagerEntry>& res, bool is_load);

rpcs3/Emu/FS/vfsDevice.cpp

@@ -45,14 +45,20 @@ u32 vfsDevice::CmpLocalPath(const wxString& local_path)
 	if(local_path.Len() < m_local_path.Len())
 		return 0;
 
-	const u32 lim = min(m_local_path.Len(), local_path.Len());
+	wxFileName path0(m_local_path);
+	path0.Normalize();
+
+	wxArrayString arr0 = wxSplit(path0.GetFullPath(), '\\');
+	wxArrayString arr1 = wxSplit(local_path, '\\');
+
+	const u32 lim = min(arr0.GetCount(), arr1.GetCount());
 	u32 ret = 0;
 
-	for(u32 i=0; i<lim; ++i, ++ret)
+	for(u32 i=0; i<lim; ret += arr0[i++].Len() + 1)
 	{
-		if(m_local_path[i] != local_path[i])
+		if(arr0[i].CmpNoCase(arr1[i]) != 0)
 		{
-			return 0;
+			break;
 		}
 	}
 
@@ -175,7 +181,9 @@ wxString vfsDevice::GetWinPath(const wxString& p, bool is_dir)
 
 	if(is_dir && ret[ret.Len() - 1] != '\\') ret += '\\';
 
-	return ret;
+	wxFileName res(ret);
+	res.Normalize();
+	return res.GetFullPath();
 }
 
 wxString vfsDevice::GetWinPath(const wxString& l, const wxString& r)
@@ -195,7 +203,7 @@ wxString vfsDevice::GetPs3Path(const wxString& p, bool is_dir)
 
 	for(u32 i=0; i<p.Len(); ++i)
 	{
-		if(p[i] == '/' || p[i] == '\\')
+		if(p[i] == L'/' || p[i] == L'\\')
 		{
 			if(!is_ls)
 			{

rpcs3/Emu/FS/vfsDevice.h

@@ -1,19 +1,8 @@
 #pragma once
-#include "vfsStream.h"
+#include "vfsFileBase.h"
-#include <mutex>
+#include "vfsDirBase.h"
 
-enum vfsOpenMode
+class vfsDevice
-{
-	vfsRead = 0x1,
-	vfsWrite = 0x2,
-	vfsExcl = 0x4,
-	vfsAppend = 0x8,
-	vfsReadWrite = vfsRead | vfsWrite,
-	vfsWriteExcl = vfsWrite | vfsExcl,
-	vfsWriteAppend = vfsWrite | vfsAppend,
-};
-
-class vfsDevice : public vfsStream
 {
 	wxString m_ps3_path;
 	wxString m_local_path;
@@ -23,9 +12,9 @@ public:
 	vfsDevice(const wxString& ps3_path, const wxString& local_path);
 	vfsDevice() {}
 
-	virtual vfsDevice* GetNew()=0;
+	virtual vfsFileBase* GetNewFileStream()=0;
-	virtual bool Open(const wxString& path, vfsOpenMode mode = vfsRead)=0;
+	virtual vfsDirBase* GetNewDirStream()=0;
-	virtual bool Create(const wxString& path)=0;
+
 	wxString GetLocalPath() const;
 	wxString GetPs3Path() const;
 

rpcs3/Emu/FS/vfsDeviceLocalFile.cpp

@@ -0,0 +1,14 @@
+#include "stdafx.h"
+#include "vfsDeviceLocalFile.h"
+#include "vfsLocalFile.h"
+#include "vfsLocalDir.h"
+
+vfsFileBase* vfsDeviceLocalFile::GetNewFileStream()
+{
+	return new vfsLocalFile(this);
+}
+
+vfsDirBase* vfsDeviceLocalFile::GetNewDirStream()
+{
+	return new vfsLocalDir(this);
+}

rpcs3/Emu/FS/vfsDeviceLocalFile.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "vfsDevice.h"
+
+class vfsDeviceLocalFile : public vfsDevice
+{
+public:
+	virtual vfsFileBase* GetNewFileStream() override;
+	virtual vfsDirBase* GetNewDirStream() override;
+};

rpcs3/Emu/FS/vfsDir.cpp

@@ -0,0 +1,70 @@
+#include "stdafx.h"
+#include "vfsDir.h"
+
+vfsDir::vfsDir()
+	: vfsDirBase(nullptr)
+	, m_stream(nullptr)
+{
+}
+
+vfsDir::vfsDir(const wxString path)
+	: vfsDirBase(nullptr)
+	, m_stream(nullptr)
+{
+	Open(path);
+}
+
+bool vfsDir::Open(const wxString& path)
+{
+	Close();
+
+	m_stream.reset(Emu.GetVFS().OpenDir(path));
+
+	return m_stream && m_stream->IsOpened();
+}
+
+bool vfsDir::Create(const wxString& path)
+{
+	return m_stream->Create(path);
+}
+
+bool vfsDir::IsExists(const wxString& path) const
+{
+	return m_stream->IsExists(path);
+}
+
+const Array<DirEntryInfo>& vfsDir::GetEntries() const
+{
+	return m_stream->GetEntries();
+}
+
+bool vfsDir::Rename(const wxString& from, const wxString& to)
+{
+	return m_stream->Rename(from, to);
+}
+
+bool vfsDir::Remove(const wxString& path)
+{
+	return m_stream->Remove(path);
+}
+
+const DirEntryInfo* vfsDir::Read()
+{
+	return m_stream->Read();
+}
+
+void vfsDir::Close()
+{
+	m_stream.reset();
+	return vfsDirBase::Close();
+}
+
+wxString vfsDir::GetPath() const
+{
+	return m_stream->GetPath();
+}
+
+bool vfsDir::IsOpened() const
+{
+	return m_stream && m_stream->IsOpened() && vfsDirBase::IsOpened();
+}

rpcs3/Emu/FS/vfsDir.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "vfsDirBase.h"
+
+class vfsDir : public vfsDirBase
+{
+private:
+	std::shared_ptr<vfsDirBase> m_stream;
+
+public:
+	vfsDir();
+	vfsDir(const wxString path);
+
+	virtual bool Open(const wxString& path) override;
+	virtual bool IsOpened() const override;
+	virtual bool IsExists(const wxString& path) const override;
+	virtual const Array<DirEntryInfo>& GetEntries() const override;
+	virtual void Close() override;
+	virtual wxString GetPath() const override;
+
+	virtual bool Create(const wxString& path) override;
+	//virtual bool Create(const DirEntryInfo& info) override;
+	virtual bool Rename(const wxString& from, const wxString& to) override;
+	virtual bool Remove(const wxString& path) override;
+	virtual const DirEntryInfo* Read() override;
+};

rpcs3/Emu/FS/vfsDirBase.cpp

@@ -1,9 +1,10 @@
 #include "stdafx.h"
 #include "vfsDirBase.h"
 
-vfsDirBase::vfsDirBase(const wxString& path)
+vfsDirBase::vfsDirBase(vfsDevice* device)
+	: m_pos(0)
+	, m_device(device)
 {
-	Open(path);
 }
 
 vfsDirBase::~vfsDirBase()
@@ -18,6 +19,7 @@ bool vfsDirBase::Open(const wxString& path)
 	if(!IsExists(path))
 		return false;
 
+	m_pos = 0;
 	m_cwd += '/' + path;
 	return true;
 }
@@ -46,4 +48,12 @@ void vfsDirBase::Close()
 wxString vfsDirBase::GetPath() const
 {
 	return m_cwd;
+}
+
+const DirEntryInfo* vfsDirBase::Read()
+{
+	if (m_pos >= m_entries.GetCount())
+		return nullptr;
+
+	return &m_entries[m_pos++];
 }

rpcs3/Emu/FS/vfsDirBase.h

@@ -32,9 +32,11 @@ class vfsDirBase
 protected:
 	wxString m_cwd;
 	Array<DirEntryInfo> m_entries;
+	uint m_pos;
+	vfsDevice* m_device;
 
 public:
-	vfsDirBase(const wxString& path);
+	vfsDirBase(vfsDevice* device);
 	virtual ~vfsDirBase();
 
 	virtual bool Open(const wxString& path);
@@ -48,4 +50,5 @@ public:
 	//virtual bool Create(const DirEntryInfo& info)=0;
 	virtual bool Rename(const wxString& from, const wxString& to)=0;
 	virtual bool Remove(const wxString& path)=0;
+	virtual const DirEntryInfo* Read();
 };

rpcs3/Emu/FS/vfsFile.cpp

@@ -2,55 +2,51 @@
 #include "vfsFile.h"
 
 vfsFile::vfsFile()
-	: vfsFileBase()
+	: vfsFileBase(nullptr)
 	, m_stream(nullptr)
 {
 }
 
 vfsFile::vfsFile(const wxString path, vfsOpenMode mode)
-	: vfsFileBase()
+	: vfsFileBase(nullptr)
 	, m_stream(nullptr)
 {
 	Open(path, mode);
 }
 
-vfsFile::~vfsFile()
-{
-	Close();
-}
-
-vfsDevice* vfsFile::GetNew()
-{
-	return new vfsFile();
-}
-
 bool vfsFile::Open(const wxString& path, vfsOpenMode mode)
 {
 	Close();
 
-	m_stream = Emu.GetVFS().Open(path, mode);
+	m_stream.reset(Emu.GetVFS().OpenFile(path, mode));
 
 	return m_stream && m_stream->IsOpened();
 }
 
 bool vfsFile::Create(const wxString& path)
 {
-	if(wxFileExists(path)) return false;
+	return m_stream->Create(path);
+}
 
-	wxFile f;
+bool vfsFile::Exists(const wxString& path)
-	return f.Create(path);
+{
+	return m_stream->Exists(path);
+}
+
+bool vfsFile::Rename(const wxString& from, const wxString& to)
+{
+	return m_stream->Rename(from, to);
+}
+
+bool vfsFile::Remove(const wxString& path)
+{
+	return m_stream->Remove(path);
 }
 
 bool vfsFile::Close()
 {
-	if(m_stream)
+	m_stream.reset();
-	{
+	return vfsFileBase::Close();
-		delete m_stream;
-		m_stream = nullptr;
-		return vfsFileBase::Close();
-	}
-
-	return false;
 }
 
 u64 vfsFile::GetSize()

rpcs3/Emu/FS/vfsFile.h

@@ -4,17 +4,17 @@
 class vfsFile : public vfsFileBase
 {
 private:
-	vfsStream* m_stream;
+	std::shared_ptr<vfsFileBase> m_stream;
 
 public:
 	vfsFile();
 	vfsFile(const wxString path, vfsOpenMode mode = vfsRead);
-	~vfsFile();
-
-	virtual vfsDevice* GetNew() override;
 
 	virtual bool Open(const wxString& path, vfsOpenMode mode = vfsRead) override;
 	virtual bool Create(const wxString& path) override;
+	virtual bool Exists(const wxString& path) override;
+	virtual bool Rename(const wxString& from, const wxString& to) override;
+	virtual bool Remove(const wxString& path) override;
 	virtual bool Close() override;
 
 	virtual u64 GetSize() override;

rpcs3/Emu/FS/vfsFileBase.cpp

@@ -1,7 +1,9 @@
 #include "stdafx.h"
 #include "vfsFileBase.h"
 
-vfsFileBase::vfsFileBase() : vfsDevice()
+vfsFileBase::vfsFileBase(vfsDevice* device)
+	: vfsStream()
+	, m_device(device)
 {
 }
 

rpcs3/Emu/FS/vfsFileBase.h

@@ -1,24 +1,37 @@
 #pragma once
-#include "vfsDevice.h"
+#include "vfsStream.h"
 
-struct vfsFileBase : public vfsDevice
+enum vfsOpenMode
+{
+	vfsRead = 0x1,
+	vfsWrite = 0x2,
+	vfsExcl = 0x4,
+	vfsAppend = 0x8,
+	vfsReadWrite = vfsRead | vfsWrite,
+	vfsWriteExcl = vfsWrite | vfsExcl,
+	vfsWriteAppend = vfsWrite | vfsAppend,
+};
+
+class vfsDevice;
+
+struct vfsFileBase : public vfsStream
 {
 protected:
 	wxString m_path;
 	vfsOpenMode m_mode;
+	vfsDevice* m_device;
 
 public:
-	vfsFileBase();
+	vfsFileBase(vfsDevice* device);
 	virtual ~vfsFileBase();
 
-	virtual bool Open(const wxString& path, vfsOpenMode mode) override;
+	virtual bool Open(const wxString& path, vfsOpenMode mode);
 	virtual bool Close() override;
-	/*
+	virtual bool Create(const wxString& path) { return false; }
-	virtual bool Create(const wxString& path)=0;
+	virtual bool Exists(const wxString& path) { return false; }
-	virtual bool Exists(const wxString& path)=0;
+	virtual bool Rename(const wxString& from, const wxString& to) { return false; }
-	virtual bool Rename(const wxString& from, const wxString& to)=0;
+	virtual bool Remove(const wxString& path) { return false; }
-	virtual bool Remove(const wxString& path)=0;
+
-	*/
 	wxString GetPath() const;
 	vfsOpenMode GetOpenMode() const;
 };

rpcs3/Emu/FS/vfsLocalDir.cpp

@@ -2,9 +2,7 @@
 #include "vfsLocalDir.h"
 #include <direct.h>
 
-vfsLocalDir::vfsLocalDir(const wxString& path)
+vfsLocalDir::vfsLocalDir(vfsDevice* device) : vfsDirBase(device)
-	: vfsDirBase(path)
-	, m_pos(0)
 {
 }
 
@@ -39,14 +37,6 @@ bool vfsLocalDir::Open(const wxString& path)
 	return true;
 }
 
-const DirEntryInfo* vfsLocalDir::Read()
-{
-	if (m_pos >= m_entries.GetCount())
-		return 0;
-
-	return &m_entries[m_pos++];
-}
-
 bool vfsLocalDir::Create(const wxString& path)
 {
 	return wxFileName::Mkdir(path, 0777, wxPATH_MKDIR_FULL);

rpcs3/Emu/FS/vfsLocalDir.h

@@ -7,11 +7,10 @@ private:
 	u32 m_pos;
 
 public:
-	vfsLocalDir(const wxString& path = wxEmptyString);
+	vfsLocalDir(vfsDevice* device);
 	virtual ~vfsLocalDir();
 
 	virtual bool Open(const wxString& path) override;
-	const DirEntryInfo* Read();
 
 	virtual bool Create(const wxString& path) override;
 	virtual bool Rename(const wxString& from, const wxString& to) override;

rpcs3/Emu/FS/vfsLocalFile.cpp

@@ -27,28 +27,27 @@ static const wxSeekMode vfs2wx_seek(vfsSeekMode mode)
 	return wxFromStart;
 }
 
-vfsLocalFile::vfsLocalFile() : vfsFileBase()
+vfsLocalFile::vfsLocalFile(vfsDevice* device) : vfsFileBase(device)
 {
 }
 
-vfsLocalFile::vfsLocalFile(const wxString path, vfsOpenMode mode) : vfsFileBase()
-{
-	Open(path, mode);
-}
-
-vfsDevice* vfsLocalFile::GetNew()
-{
-	return new vfsLocalFile();
-}
-
 bool vfsLocalFile::Open(const wxString& path, vfsOpenMode mode)
 {
 	Close();
 
-	if(!m_file.Access(vfsDevice::GetWinPath(GetLocalPath(), path), vfs2wx_mode(mode))) return false;
+	if(m_device)
+	{
+		if(!m_file.Access(vfsDevice::GetWinPath(m_device->GetLocalPath(), path), vfs2wx_mode(mode))) return false;
 
-	return m_file.Open(vfsDevice::GetWinPath(GetLocalPath(), path), vfs2wx_mode(mode)) &&
+		return m_file.Open(vfsDevice::GetWinPath(m_device->GetLocalPath(), path), vfs2wx_mode(mode)) &&
-		vfsFileBase::Open(vfsDevice::GetPs3Path(GetPs3Path(), path), mode);
+			vfsFileBase::Open(vfsDevice::GetPs3Path(m_device->GetPs3Path(), path), mode);
+	}
+	else
+	{
+		if(!m_file.Access(path, vfs2wx_mode(mode))) return false;
+
+		return m_file.Open(path, vfs2wx_mode(mode)) && vfsFileBase::Open(path, mode);
+	}
 }
 
 bool vfsLocalFile::Create(const wxString& path)

rpcs3/Emu/FS/vfsLocalFile.h

@@ -7,9 +7,7 @@ private:
 	wxFile m_file;
 
 public:
-	vfsLocalFile();
+	vfsLocalFile(vfsDevice* device);
-	vfsLocalFile(const wxString path, vfsOpenMode mode = vfsRead);
-	vfsDevice* GetNew();
 
 	virtual bool Open(const wxString& path, vfsOpenMode mode = vfsRead) override;
 	virtual bool Create(const wxString& path) override;

rpcs3/Emu/GS/GL/GLGSRender.cpp

@@ -12,6 +12,7 @@
 #endif
 
 gcmBuffer gcmBuffers[8];
+GLuint flipTex;
 
 int last_width = 0, last_height = 0, last_depth_format = 0;
 
@@ -85,12 +86,15 @@ GLGSRender::GLGSRender()
 	, m_context(nullptr)
 {
 	m_frame = new GLGSFrame();
+
+	glGenTextures(1, &flipTex);
 }
 
 GLGSRender::~GLGSRender()
 {
 	m_frame->Close();
 	delete m_context;
+	glDeleteTextures(1, &flipTex);
 }
 
 void GLGSRender::Enable(bool enable, const u32 cap)
@@ -304,17 +308,39 @@ void GLGSRender::DisableVertexData()
 
 void GLGSRender::InitVertexData()
 {
+	GLfloat scaleOffsetMat[16] = {1.0f, 0.0f, 0.0f, 0.0f, 
+		                          0.0f, 1.0f, 0.0f, 0.0f, 
+								  0.0f, 0.0f, 1.0f, 0.0f, 
+								  0.0f, 0.0f, 0.0f, 1.0f};
+	int l;
+
 	for(u32 i=0; i<m_transform_constants.GetCount(); ++i)
 	{
 		const RSXTransformConstant& c = m_transform_constants[i];
 		const wxString name = wxString::Format("vc%u", c.id);
-		const int l = m_program.GetLocation(name);
+		l = m_program.GetLocation(name);
 		checkForGlError("glGetUniformLocation " + name);
 
 		//ConLog.Write(name + " x: %.02f y: %.02f z: %.02f w: %.02f", c.x, c.y, c.z, c.w);
 		glUniform4f(l, c.x, c.y, c.z, c.w);
 		checkForGlError("glUniform4f " + name + wxString::Format(" %d [%f %f %f %f]", l, c.x, c.y, c.z, c.w));
 	}
+
+	// Scale
+	scaleOffsetMat[0]  = (GLfloat&)methodRegisters[NV4097_SET_VIEWPORT_SCALE + (0x4*0)] / (m_width / 2.0f);
+	scaleOffsetMat[5]  = (GLfloat&)methodRegisters[NV4097_SET_VIEWPORT_SCALE + (0x4*1)] / (m_height / 2.0f);
+	scaleOffsetMat[10] = (GLfloat&)methodRegisters[NV4097_SET_VIEWPORT_SCALE + (0x4*2)];
+
+	// Offset
+	scaleOffsetMat[3]  = (GLfloat&)methodRegisters[NV4097_SET_VIEWPORT_OFFSET + (0x4*0)] - (m_width / 2.0f);
+	scaleOffsetMat[7]  = (GLfloat&)methodRegisters[NV4097_SET_VIEWPORT_OFFSET + (0x4*1)] - (m_height / 2.0f);
+	scaleOffsetMat[11] = (GLfloat&)methodRegisters[NV4097_SET_VIEWPORT_OFFSET + (0x4*2)] - 1/2.0f;
+
+	scaleOffsetMat[3] /= m_width / 2.0f;
+	scaleOffsetMat[7] /= m_height / 2.0f;
+
+	l = m_program.GetLocation("scaleOffsetMat");
+	glUniformMatrix4fv(l, 1, false, scaleOffsetMat);
 }
 
 void GLGSRender::InitFragmentData()
@@ -736,13 +762,13 @@ void GLGSRender::ExecCMD()
 
 	if(m_set_viewport_horizontal && m_set_viewport_vertical)
 	{
-		glViewport(m_viewport_x, RSXThread::m_height-m_viewport_y-m_viewport_h, m_viewport_w, m_viewport_h);
+		//glViewport(m_viewport_x, m_viewport_y, m_viewport_w, m_viewport_h);
 		checkForGlError("glViewport");
 	}
 
 	if(m_set_scissor_horizontal && m_set_scissor_vertical)
 	{
-		glScissor(m_scissor_x, RSXThread::m_height-m_scissor_y-m_scissor_h, m_scissor_w, m_scissor_h);
+		glScissor(m_scissor_x, m_scissor_y, m_scissor_w, m_scissor_h);
 		checkForGlError("glScissor");
 	}
 
@@ -1029,6 +1055,12 @@ void GLGSRender::ExecCMD()
 
 void GLGSRender::Flip()
 {
+	if(m_set_scissor_horizontal && m_set_scissor_vertical)
+	{
+		glScissor(0, 0, RSXThread::m_width, RSXThread::m_height);
+		checkForGlError("glScissor");
+	}
+
 	if(m_read_buffer)
 	{
 		gcmBuffer* buffers = (gcmBuffer*)Memory.GetMemFromAddr(m_gcm_buffers_addr);
@@ -1054,12 +1086,47 @@ void GLGSRender::Flip()
 	}
 	else if(m_fbo.IsCreated())
 	{
+		Array<u8> pixels;
+		pixels.SetCount(m_width * m_height * 4);
+
 		m_fbo.Bind(GL_READ_FRAMEBUFFER);
+		glReadPixels(0, 0, m_width, m_height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, pixels.GetPtr());
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, flipTex);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, pixels.GetPtr());
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+		glMatrixMode(GL_PROJECTION);
+		glLoadIdentity();
+		glOrtho(0, 1, 0, 1, 0, 1);
+		glMatrixMode(GL_MODELVIEW);
+		glLoadIdentity();
+
 		GLfbo::Bind(GL_DRAW_FRAMEBUFFER, 0);
+
+		m_program.UnUse();
+		m_program.Use();
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);
+		glBegin(GL_QUADS);
+		glTexCoord2i(0, 1);
+		glVertex2i(0, 0);
+
+		glTexCoord2i(1, 1);
+		glVertex2i(1, 0);
+
+		glTexCoord2i(1, 0);
+		glVertex2i(1, 1);
+
+		glTexCoord2i(0, 0);
+		glVertex2i(0, 1);
+		glEnd();
+
+		/*GLfbo::Bind(GL_DRAW_FRAMEBUFFER, 0);
 		GLfbo::Blit(
 			m_surface_clip_x, m_surface_clip_y, m_surface_clip_x + m_surface_clip_w, m_surface_clip_y + m_surface_clip_h,
 			m_surface_clip_x, m_surface_clip_y, m_surface_clip_x + m_surface_clip_w, m_surface_clip_y + m_surface_clip_h,
-			GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_NEAREST);
+			GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, GL_NEAREST);*/
 		m_fbo.Bind();
 	}
 
@@ -1072,4 +1139,39 @@ void GLGSRender::Flip()
 
 	if(m_fbo.IsCreated())
 		m_fbo.Bind();
+
+  if(m_set_scissor_horizontal && m_set_scissor_vertical)
+	{
+		glScissor(m_scissor_x, m_scissor_y, m_scissor_w, m_scissor_h);
+		checkForGlError("glScissor");
+	}
+}
+
+uint32_t LinearToSwizzleAddress(
+	uint32_t x, uint32_t y, uint32_t z,
+	uint32_t log2_width, uint32_t log2_height, uint32_t log2_depth)
+{
+	uint32_t offset = 0;
+	uint32_t shift_count = 0;
+	while(log2_width | log2_height | log2_depth){
+		if(log2_width){
+			offset |= (x & 0x01) << shift_count;
+			x >>= 1;
+			++shift_count;
+			--log2_width;
+		}
+		if(log2_height){
+			offset |= (y & 0x01) << shift_count;
+			y >>= 1;
+			++shift_count;
+			--log2_height;
+		}
+		if(log2_depth){
+			offset |= (z & 0x01) << shift_count;
+			z >>= 1;
+			++shift_count;
+			--log2_depth;
+		}
+	}
+	return offset;
 }

rpcs3/Emu/GS/GL/GLGSRender.h

@@ -13,6 +13,9 @@
 
 extern GLenum g_last_gl_error;
 void printGlError(GLenum err, const char* situation);
+uint32_t LinearToSwizzleAddress(
+	uint32_t x, uint32_t y, uint32_t z,
+	uint32_t log2_width, uint32_t log2_height, uint32_t log2_depth);
 
 #if RSX_DEBUG
 #define checkForGlError(sit) if((g_last_gl_error = glGetError()) != GL_NO_ERROR) printGlError(g_last_gl_error, sit)
@@ -51,9 +54,11 @@ public:
 		case 1: return GL_REPEAT;
 		case 2: return GL_MIRRORED_REPEAT;
 		case 3: return GL_CLAMP_TO_EDGE;
-		case 4: return GL_TEXTURE_BORDER;
+		case 4: return GL_CLAMP_TO_BORDER;
-		case 5: return GL_CLAMP_TO_EDGE;//GL_CLAMP;
+		case 5: return GL_CLAMP_TO_EDGE;
-		//case 6: return GL_MIRROR_CLAMP_TO_EDGE_EXT;
+		case 6: return GL_MIRROR_CLAMP_TO_EDGE_EXT;
+		case 7: return GL_MIRROR_CLAMP_TO_BORDER_EXT;
+		case 8: return GL_MIRROR_CLAMP_EXT;
 		}
 
 		ConLog.Error("Texture wrap error: bad wrap (%d).", wrap);
@@ -63,9 +68,9 @@ public:
 	void Init(RSXTexture& tex)
 	{
 		Bind();
-		if(!Memory.IsGoodAddr(tex.GetOffset()))
+		if(!Memory.IsGoodAddr(GetAddress(tex.GetOffset(), tex.GetLocation())))
 		{
-			ConLog.Error("Bad texture address=0x%x", tex.GetOffset());
+			ConLog.Error("Bad texture address=0x%x", GetAddress(tex.GetOffset(), tex.GetLocation()));
 			return;
 		}
 		//ConLog.Warning("texture addr = 0x%x, width = %d, height = %d, max_aniso=%d, mipmap=%d, remap=0x%x, zfunc=0x%x, wraps=0x%x, wrapt=0x%x, wrapr=0x%x, minlod=0x%x, maxlod=0x%x", 
@@ -77,12 +82,13 @@ public:
 		bool is_swizzled = (tex.GetFormat() & 0x20) == 0;
 
 		glPixelStorei(GL_PACK_ALIGNMENT, tex.m_pitch);
-		char* pixels = (char*)Memory.GetMemFromAddr(tex.GetOffset());
+		char* pixels = (char*)Memory.GetMemFromAddr(GetAddress(tex.GetOffset(), tex.GetLocation()));
+		char* unswizzledPixels;
 
 		switch(format)
 		{
 		case 0x81:
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.m_width, tex.m_height, 0, GL_BLUE, GL_UNSIGNED_BYTE, pixels);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.GetWidth(), tex.GetHeight(), 0, GL_BLUE, GL_UNSIGNED_BYTE, pixels);
 			checkForGlError("GLTexture::Init() -> glTexImage2D");
 			
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
@@ -94,39 +100,60 @@ public:
 		break;
 
 		case 0x85:
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.m_width, tex.m_height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, pixels);
+			if(is_swizzled)
+			{
+				uint32_t *src, *dst;
+				uint32_t log2width, log2height;
+
+				unswizzledPixels = (char*)malloc(tex.GetWidth() * tex.GetHeight() * 4);
+				src = (uint32_t*)pixels;
+				dst = (uint32_t*)unswizzledPixels;
+
+				log2width = log(tex.GetWidth())/log(2);
+				log2height = log(tex.GetHeight())/log(2);
+
+				for(int i=0; i<tex.GetHeight(); i++)
+				{
+					for(int j=0; j<tex.GetWidth(); j++)
+					{
+						dst[(i*tex.GetHeight()) + j] = src[LinearToSwizzleAddress(j, i, 0, log2width, log2height, 0)];
+					}
+				}
+			}
+
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.GetWidth(), tex.GetHeight(), 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, is_swizzled ? unswizzledPixels : pixels);
 			checkForGlError("GLTexture::Init() -> glTexImage2D");
 		break;
 
 		case 0x86:
 		{
-			u32 size = ((tex.m_width + 3) / 4) * ((tex.m_height + 3) / 4) * 8;
+			u32 size = ((tex.GetWidth() + 3) / 4) * ((tex.GetHeight() + 3) / 4) * 8;
 
-			glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, tex.m_width, tex.m_height, 0, size, pixels);
+			glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, tex.GetWidth(), tex.GetHeight(), 0, size, pixels);
 			checkForGlError("GLTexture::Init() -> glCompressedTexImage2D");
 		}
 		break;
 
 		case 0x87:
 		{
-			u32 size = ((tex.m_width + 3) / 4) * ((tex.m_height + 3) / 4) * 16;
+			u32 size = ((tex.GetWidth() + 3) / 4) * ((tex.GetHeight() + 3) / 4) * 16;
 
-			glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, tex.m_width, tex.m_height, 0, size, pixels);
+			glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, tex.GetWidth(), tex.GetHeight(), 0, size, pixels);
 			checkForGlError("GLTexture::Init() -> glCompressedTexImage2D");
 		}
 		break;
 
 		case 0x88:
 		{
-			u32 size = ((tex.m_width + 3) / 4) * ((tex.m_height + 3) / 4) * 16;
+			u32 size = ((tex.GetWidth() + 3) / 4) * ((tex.GetHeight() + 3) / 4) * 16;
 
-			glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, tex.m_width, tex.m_height, 0, size, pixels);
+			glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, tex.GetWidth(), tex.GetHeight(), 0, size, pixels);
 			checkForGlError("GLTexture::Init() -> glCompressedTexImage2D");
 		}
 		break;
 		
 		case 0x94:
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.m_width, tex.m_height, 0, GL_RED, GL_SHORT, pixels);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.GetWidth(), tex.GetHeight(), 0, GL_RED, GL_SHORT, pixels);
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_ONE);
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_ONE);
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_ONE);
@@ -135,30 +162,30 @@ public:
 		break;
 
 		case 0x9a:
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.m_width, tex.m_height, 0, GL_BGRA, GL_HALF_FLOAT, pixels);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.GetWidth(), tex.GetHeight(), 0, GL_BGRA, GL_HALF_FLOAT, pixels);
 			checkForGlError("GLTexture::Init() -> glTexImage2D");
 		break;
 
 		case 0x9e:
 		{
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.m_width, tex.m_height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, pixels);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex.GetWidth(), tex.GetHeight(), 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, pixels);
 			checkForGlError("GLTexture::Init() -> glTexImage2D");
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ONE);
 		}
 		break;
 
-		default: ConLog.Error("Init tex error: Bad tex format (0x%x | 0x%x | 0x%x)", format, tex.GetFormat() & 0x20, tex.GetFormat() & 0x40); break;
+		default: ConLog.Error("Init tex error: Bad tex format (0x%x | %s | 0x%x)", format, is_swizzled ? "swizzled" : "linear", tex.GetFormat() & 0x40); break;
 		}
 
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, tex.m_mipmap - 1);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, tex.Getmipmap() - 1);
-		glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, tex.m_mipmap > 1);
+		glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, tex.Getmipmap() > 1);
 
 		if(format != 0x81 && format != 0x94)
 		{
-			u8 remap_a = tex.m_remap & 0x3;
+			u8 remap_a = tex.GetRemap() & 0x3;
-			u8 remap_r = (tex.m_remap >> 2) & 0x3;
+			u8 remap_r = (tex.GetRemap() >> 2) & 0x3;
-			u8 remap_g = (tex.m_remap >> 4) & 0x3;
+			u8 remap_g = (tex.GetRemap() >> 4) & 0x3;
-			u8 remap_b = (tex.m_remap >> 6) & 0x3;
+			u8 remap_b = (tex.GetRemap() >> 6) & 0x3;
 
 			static const int gl_remap[] =
 			{
@@ -174,6 +201,8 @@ public:
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, gl_remap[remap_b]);
 		}
 		
+		checkForGlError("GLTexture::Init() -> remap");
+
 		static const int gl_tex_zfunc[] =
 		{
 			GL_NEVER,
@@ -186,14 +215,18 @@ public:
 			GL_ALWAYS,
 		};
 		
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GetGlWrap(tex.m_wraps));
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GetGlWrap(tex.GetWrapS()));
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GetGlWrap(tex.m_wrapt));
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GetGlWrap(tex.GetWrapT()));
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GetGlWrap(tex.m_wrapr));
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GetGlWrap(tex.GetWrapR()));
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, gl_tex_zfunc[tex.m_zfunc]);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, gl_tex_zfunc[tex.GetZfunc()]);
+
+		checkForGlError("GLTexture::Init() -> parameters1");
 		
-		glTexEnvi(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, tex.m_bias);
+		glTexEnvi(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, tex.GetBias());
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, tex.m_minlod);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, (tex.GetMinLOD() >> 8));
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, tex.m_maxlod);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, (tex.GetMaxLOD() >> 8));
+
+		checkForGlError("GLTexture::Init() -> parameters2");
 		
 		static const int gl_tex_filter[] =
 		{
@@ -207,20 +240,28 @@ public:
 			GL_NEAREST,
 		};
 
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_tex_filter[tex.m_min_filter]);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_tex_filter[tex.GetMinFilter()]);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_tex_filter[tex.m_mag_filter]);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_tex_filter[tex.GetMagFilter()]);
+
+		checkForGlError("GLTexture::Init() -> filters");
+
 		//Unbind();
+
+		if(is_swizzled && format == 0x85)
+		{
+			free(unswizzledPixels);
+		}
 	}
 
 	void Save(RSXTexture& tex, const wxString& name)
 	{
-		if(!m_id || !tex.m_offset || !tex.m_width || !tex.m_height) return;
+    if(!m_id || !tex.GetOffset() || !tex.GetWidth() || !tex.GetHeight()) return;
 
-		u32* alldata = new u32[tex.m_width * tex.m_height];
+		u32* alldata = new u32[tex.GetWidth() * tex.GetHeight()];
 
 		Bind();
 
-		switch(tex.m_format & ~(0x20 | 0x40))
+		switch(tex.GetFormat() & ~(0x20 | 0x40))
 		{
 		case 0x81:
 			glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, alldata);
@@ -237,15 +278,15 @@ public:
 
 		{
 			wxFile f(name + ".raw", wxFile::write);
-			f.Write(alldata, tex.m_width * tex.m_height * 4);
+			f.Write(alldata, tex.GetWidth() * tex.GetHeight() * 4);
 		}
-		u8* data = new u8[tex.m_width * tex.m_height * 3];
+		u8* data = new u8[tex.GetWidth() * tex.GetHeight() * 3];
-		u8* alpha = new u8[tex.m_width * tex.m_height];
+		u8* alpha = new u8[tex.GetWidth() * tex.GetHeight()];
 
 		u8* src = (u8*)alldata;
 		u8* dst_d = data;
 		u8* dst_a = alpha;
-		for(u32 i=0; i<tex.m_width*tex.m_height;i++)
+		for(u32 i=0; i<tex.GetWidth()*tex.GetHeight();i++)
 		{
 			*dst_d++ = *src++;
 			*dst_d++ = *src++;
@@ -254,7 +295,7 @@ public:
 		}
 
 		wxImage out;
-		out.Create(tex.m_width, tex.m_height, data, alpha);
+		out.Create(tex.GetWidth(), tex.GetHeight(), data, alpha);
 		out.SaveFile(name, wxBITMAP_TYPE_PNG);
 
 		free(alldata);

rpcs3/Emu/GS/GL/GLVertexProgram.cpp

@@ -319,7 +319,7 @@ wxString GLVertexDecompilerThread::BuildCode()
 
 	wxString f = wxEmptyString;
 
-	f += wxString::Format("void %s()\n{\n\tgl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);\n%s}\n", m_funcs[0].name.wx_str(), BuildFuncBody(m_funcs[0]).wx_str());
+	f += wxString::Format("void %s()\n{\n\tgl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);\n%sgl_Position = gl_Position * scaleOffsetMat;\n}\n", m_funcs[0].name.wx_str(), BuildFuncBody(m_funcs[0]).wx_str());
 
 	for(uint i=1; i<m_funcs.GetCount(); ++i)
 	{
@@ -329,6 +329,7 @@ wxString GLVertexDecompilerThread::BuildCode()
 	static const wxString& prot = 
 		"#version 330\n"
 		"\n"
+		"uniform mat4 scaleOffsetMat = mat4(1.0);\n"
 		"%s\n"
 		"%s\n"
 		"%s";

rpcs3/Emu/GS/RSXTexture.cpp

@@ -0,0 +1,202 @@
+#include "stdafx.h"
+#include "RSXThread.h"
+
+RSXTexture::RSXTexture()
+{
+  m_index = 0;
+}
+
+RSXTexture::RSXTexture(u8 index)
+{
+  m_index = index;
+}
+
+void RSXTexture::Init()
+{
+	// Offset
+	methodRegisters[NV4097_SET_TEXTURE_OFFSET + (m_index*32)] = 0;
+
+	// Format
+	methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] = 0;
+
+	// Address
+	methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] =
+		((/*wraps*/1) | ((/*anisoBias*/0) << 4) | ((/*wrapt*/1) << 8) | ((/*unsignedRemap*/0) << 12) | 
+		 ((/*wrapr*/2) << 16) | ((/*gamma*/0) << 20) |((/*signedRemap*/0) << 24) | ((/*zfunc*/0) << 28));
+
+	// Control0
+	methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] =
+		(((/*alphakill*/0) << 2) | (/*maxaniso*/0) << 4) | ((/*maxlod*/0xc00) << 7) | ((/*minlod*/0) << 19) | ((/*enable*/0) << 31);
+
+	// Control1
+	methodRegisters[NV4097_SET_TEXTURE_CONTROL1 + (m_index*32)] = 0xE4;
+
+	// Filter
+	methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] =
+		((/*bias*/0) | ((/*conv*/1) << 13) | ((/*min*/5) << 16) | ((/*mag*/2) << 24) 
+		       | ((/*as*/0) << 28) | ((/*rs*/0) << 29) | ((/*gs*/0) << 30) | ((/*bs*/0) << 31) );
+
+	// Image Rect
+	methodRegisters[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index*32)] = (/*height*/1) | ((/*width*/1) << 16);
+}
+
+u32 RSXTexture::GetOffset() const
+{
+  return methodRegisters[NV4097_SET_TEXTURE_OFFSET + (m_index*32)];
+}
+
+u8 RSXTexture::GetLocation() const
+{
+  return (methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] & 0x3) - 1;
+}
+
+bool RSXTexture::isCubemap() const
+{
+  return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 2) & 0x1);
+}
+
+u8 RSXTexture::GetBorderType() const
+{
+  return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 3) & 0x1);
+}
+
+u8 RSXTexture::GetDimension() const
+{
+  return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 4) & 0xf);
+}
+
+u8 RSXTexture::GetFormat() const
+{
+  return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 8) & 0xff);
+}
+
+u16 RSXTexture::Getmipmap() const
+{
+  return ((methodRegisters[NV4097_SET_TEXTURE_FORMAT + (m_index*32)] >> 16) & 0xffff);
+}
+
+u8 RSXTexture::GetWrapS() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)]) & 0xf);
+}
+
+u8 RSXTexture::GetWrapT() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 8) & 0xf);
+}
+
+u8 RSXTexture::GetWrapR() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 16) & 0xf);
+}
+
+u8 RSXTexture::GetUnsignedRemap() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 12) & 0xf);
+}
+
+u8 RSXTexture::GetZfunc() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 28) & 0xf);
+}
+
+u8 RSXTexture::GetGamma() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 20) & 0xf);
+}
+
+u8 RSXTexture::GetAnisoBias() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 4) & 0xf);
+}
+
+u8 RSXTexture::GetSignedRemap() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_ADDRESS + (m_index*32)] >> 24) & 0xf);
+}
+
+bool RSXTexture::IsEnabled() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 31) & 0x1);
+}
+
+u16  RSXTexture::GetMinLOD() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 19) & 0xfff);
+}
+
+u16  RSXTexture::GetMaxLOD() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 7) & 0xfff);
+}
+
+u8   RSXTexture::GetMaxAniso() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 4) & 0x7);
+}
+
+bool RSXTexture::IsAlphaKillEnabled() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_CONTROL0 + (m_index*32)] >> 2) & 0x1);
+}
+
+u32 RSXTexture::GetRemap() const
+{
+	return (methodRegisters[NV4097_SET_TEXTURE_CONTROL1 + (m_index*32)]);
+}
+
+u16 RSXTexture::GetBias() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)]) & 0x1fff);
+}
+
+u8  RSXTexture::GetMinFilter() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 16) & 0x7);
+}
+
+u8  RSXTexture::GetMagFilter() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 24) & 0x7);
+}
+
+u8 RSXTexture::GetConvolutionFilter() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 13) & 0xf);
+}
+
+bool RSXTexture::isASigned() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 28) & 0x1);
+}
+
+bool RSXTexture::isRSigned() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 29) & 0x1);
+}
+
+bool RSXTexture::isGSigned() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 30) & 0x1);
+}
+
+bool RSXTexture::isBSigned() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_FILTER + (m_index*32)] >> 31) & 0x1);
+}
+
+u16 RSXTexture::GetWidth() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index*32)] >> 16) & 0xffff);
+}
+
+u16 RSXTexture::GetHeight() const
+{
+	return ((methodRegisters[NV4097_SET_TEXTURE_IMAGE_RECT + (m_index*32)]) & 0xffff);
+}
+
+void RSXTexture::SetControl3(u16 depth, u32 pitch)
+{
+  m_depth = depth;
+  m_pitch = pitch;
+}

rpcs3/Emu/GS/RSXThread.cpp

@@ -3,6 +3,21 @@
 
 #define ARGS(x) (Memory.Read32(Memory.RSXIOMem.GetStartAddr() + re(m_ctrl->get) + (4*(x+1))))
 
+u32 methodRegisters[0xffff];
+
+u32 GetAddress(u32 offset, u8 location)
+{
+	switch(location)
+	{
+	case CELL_GCM_LOCATION_LOCAL: return Memory.RSXFBMem.GetStartAddr() + offset;
+	case CELL_GCM_LOCATION_MAIN: return Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + offset);
+	}
+
+	ConLog.Error("GetAddress(offset=0x%x, location=0x%x)", location);
+	assert(0);
+	return 0;
+}
+
 RSXVertexData::RSXVertexData()
 	: frequency(0)
 	, stride(0)
@@ -185,47 +200,11 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 
 	case_16(NV4097_SET_TEXTURE_OFFSET, 0x20):
 	{
-		RSXTexture& tex = m_textures[index];
-		const u32 offset = ARGS(0);
-		u32 a1 = ARGS(1);
-		u8 location = (a1 & 0x3) - 1;
-		const bool cubemap = (a1 >> 2) & 0x1;
-		const u8 dimension = (a1 >> 4) & 0xf;
-		const u8 format = (a1 >> 8) & 0xff;
-		const u16 mipmap = (a1 >> 16) & 0xffff;
-		CMD_LOG("index = %d, offset=0x%x, location=0x%x, cubemap=0x%x, dimension=0x%x, format=0x%x, mipmap=0x%x",
-			index, offset, location, cubemap, dimension, format, mipmap);
-
-		if(location == 2)
-		{
-			ConLog.Error("Bad texture location.");
-			location = 1;
-		}
-		u32 tex_addr = GetAddress(offset, location);
-		if(!Memory.IsGoodAddr(tex_addr))
-			ConLog.Error("Bad texture[%d] addr = 0x%x #offset = 0x%x, location=%d", index, tex_addr, offset, location);
-		//ConLog.Warning("texture addr = 0x%x #offset = 0x%x, location=%d", tex_addr, offset, location);
-		tex.SetOffset(tex_addr);
-		tex.SetFormat(cubemap, dimension, format, mipmap);
-
-		if(!tex.m_width || !tex.m_height)
-		{
-			gcmBuffer* buffers = (gcmBuffer*)Memory.GetMemFromAddr(m_gcm_buffers_addr);
-			if(!tex.m_width) tex.m_width = re(buffers[m_gcm_current_buffer].width);
-			if(!tex.m_height) tex.m_height = re(buffers[m_gcm_current_buffer].height);
-		}
 	}
 	break;
 
 	case_16(NV4097_SET_TEXTURE_CONTROL0, 0x20):
 	{
-		RSXTexture& tex = m_textures[index];
-		u32 a0 = ARGS(0);
-		bool enable = a0 >> 31 ? true : false;
-		u16 minlod = (a0 >> 19) & 0xfff;
-		u16 maxlod = (a0 >> 7) & 0xfff;
-		u8 maxaniso = (a0 >> 2) & 0x7;
-		tex.SetControl0(enable, minlod, maxlod, maxaniso);
 	}
 	break;
 	
@@ -294,8 +273,6 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 
 	case_16(NV4097_SET_TEXTURE_CONTROL1, 0x20):
 	{
-		RSXTexture& tex = m_textures[index];
-		tex.SetControl1(ARGS(0));
 	}
 	break;
 
@@ -311,36 +288,11 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 
 	case_16(NV4097_SET_TEXTURE_FILTER, 0x20):
 	{
-		RSXTexture& tex = m_textures[index];
-		u32 a0 = ARGS(0);
-		u16 bias = a0 & 0x1fff;
-		u8 conv = (a0 >> 13) & 0xf;
-		u8 min = (a0 >> 16) & 0x7;
-		u8 mag = (a0 >> 24) & 0x7;
-		u8 a_signed = (a0 >> 28) & 0x1;
-		u8 r_signed = (a0 >> 29) & 0x1;
-		u8 g_signed = (a0 >> 30) & 0x1;
-		u8 b_signed = (a0 >> 31) & 0x1;
-
-		tex.SetFilter(bias, min, mag, conv, a_signed, r_signed, g_signed, b_signed);
 	}
 	break;
 
 	case_16(NV4097_SET_TEXTURE_ADDRESS, 0x20):
 	{
-		RSXTexture& tex = m_textures[index];
-
-		u32 a0 = ARGS(0);
-		u8 wraps			= a0 & 0xf;
-		u8 aniso_bias		= (a0 >> 4) & 0xf;
-		u8 wrapt			= (a0 >> 8) & 0xf;
-		u8 unsigned_remap	= (a0 >> 12) & 0xf;
-		u8 wrapr			= (a0 >> 16) & 0xf;
-		u8 gamma			= (a0 >> 20) & 0xf;
-		u8 signed_remap		= (a0 >> 24) & 0xf;
-		u8 zfunc			= a0 >> 28;
-
-		tex.SetAddress(wraps, wrapt, wrapr, unsigned_remap, zfunc, gamma, aniso_bias, signed_remap);
 	}
 	break;
 
@@ -350,26 +302,6 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 
 	case_16(NV4097_SET_TEXTURE_IMAGE_RECT, 32):
 	{
-		RSXTexture& tex = m_textures[index];
-
-		u16 height = ARGS(0) & 0xffff;
-		u16 width = ARGS(0) >> 16;
-		CMD_LOG("width=%d, height=%d", width, height);
-
-		if(!width || !height)
-		{
-			ConLog.Warning("Bad texture rect: %dx%d (%dx%d)", width, height, tex.m_width, tex.m_height);
-			for(int i=0; i<count; ++i)
-			{
-				ConLog.Warning("*** 0x%x", ARGS(i));
-			}
-
-			if(!width) width = tex.m_width;
-			if(!height) height = tex.m_height;
-		}
-		tex.SetRect(width, height);
-
-
 	}
 	break;
 
@@ -1391,6 +1323,11 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
 		m_fog_param1 = (float&)a1;
 	}
 	break;
+	case NV4097_SET_VIEWPORT_SCALE:
+	{
+
+	}
+	break;
 
 	default:
 	{
@@ -1427,11 +1364,6 @@ void RSXThread::End()
 		//Emu.GetCallbackManager().m_exit_callback.Handle(0x0122, 0);
 	}
 
-	for(uint i=0; i<m_textures_count; ++i)
-	{
-		m_textures[i].m_enabled = false;
-	}
-
 	m_indexed_array.Reset();
 	m_fragment_constants.Clear();
 	m_transform_constants.Clear();
@@ -1446,6 +1378,7 @@ void RSXThread::End()
 
 void RSXThread::Task()
 {
+  u8 inc;
 	ConLog.Write("RSX thread entry");
 
 	OnInitThread();
@@ -1454,6 +1387,8 @@ void RSXThread::Task()
 	{
 		wxCriticalSectionLocker lock(m_cs_main);
 
+    inc=1;
+
 		u32 put, get;
 		se_t<u32>::func(put, std::atomic_load((volatile std::atomic<u32>*)((u8*)m_ctrl + offsetof(CellGcmControl, put))));
 		se_t<u32>::func(get, std::atomic_load((volatile std::atomic<u32>*)((u8*)m_ctrl + offsetof(CellGcmControl, get))));
@@ -1504,6 +1439,7 @@ void RSXThread::Task()
 		if(cmd & CELL_GCM_METHOD_FLAG_NON_INCREMENT)
 		{
 			//ConLog.Warning("non increment cmd! 0x%x", cmd);
+      inc=0;
 		}
 
 		if(cmd == 0)
@@ -1513,6 +1449,11 @@ void RSXThread::Task()
 			continue;
 		}
 
+    for(int i=0; i<count; i++)
+    {
+      methodRegisters[(cmd & 0xffff) + (i*4*inc)] = ARGS(i);
+    }
+
 		mem32_ptr_t args(Memory.RSXIOMem.GetStartAddr() + get + 4);
 		DoCmd(cmd, cmd & 0x3ffff, args, count);
 

rpcs3/Emu/GS/RSXThread.h

@@ -12,144 +12,67 @@ enum Method
 	CELL_GCM_METHOD_FLAG_RETURN			= 0x00020000,
 };
 
+extern u32 methodRegisters[0xffff];
+u32 GetAddress(u32 offset, u8 location);
 
 class RSXTexture
 {
+  u8 m_index;
 public:
-	bool m_enabled;
-
-	u32 m_width, m_height;
-	u32 m_offset;
-
-	bool m_cubemap;
-	u8 m_dimension;
-	u32 m_format;
-	u16 m_mipmap;
-
 	u32 m_pitch;
 	u16 m_depth;
 
-	u16 m_minlod;
-	u16 m_maxlod;
-	u8 m_maxaniso;
-
-	u8 m_wraps;
-	u8 m_wrapt;
-	u8 m_wrapr;
-	u8 m_unsigned_remap;
-	u8 m_zfunc;
-	u8 m_gamma;
-	u8 m_aniso_bias;
-	u8 m_signed_remap;
-
-	u16 m_bias;
-	u8 m_min_filter;
-	u8 m_mag_filter;
-	u8 m_conv;
-	u8 m_a_signed;
-	u8 m_r_signed;
-	u8 m_g_signed;
-	u8 m_b_signed;
-
-	u32 m_remap;
-
 public:
-	RSXTexture()
+	RSXTexture();
-		: m_width(0), m_height(0)
+	RSXTexture(u8 index);
-		, m_offset(0)
+	void Init();
-		, m_enabled(false)
 
-		, m_cubemap(false)
+	// Offset
-		, m_dimension(0)
+	u32 GetOffset() const;
-		, m_format(0)
-		, m_mipmap(0)
-		, m_minlod(0)
-		, m_maxlod(1000)
-		, m_maxaniso(0)
-	{
-	}
 
-	void SetRect(const u32 width, const u32 height)
+	// Format
-	{
+	u8   GetLocation() const;
-		m_width = width;
+	bool isCubemap() const;
-		m_height = height;
+	u8   GetBorderType() const;
-	}
+	u8   GetDimension() const;
+	u8   GetFormat() const;
+	u16  Getmipmap() const;
 
-	void SetFormat(const bool cubemap, const u8 dimension, const u32 format, const u16 mipmap)
+	// Address
-	{
+	u8 GetWrapS() const;
-		m_cubemap = cubemap;
+	u8 GetWrapT() const;
-		m_dimension = dimension;
+	u8 GetWrapR() const;
-		m_format = format;
+	u8 GetUnsignedRemap() const;
-		m_mipmap = mipmap;
+	u8 GetZfunc() const;
-	}
+	u8 GetGamma() const;
+	u8 GetAnisoBias() const;
+	u8 GetSignedRemap() const;
 
-	void SetAddress(u8 wraps, u8 wrapt, u8 wrapr, u8 unsigned_remap, u8 zfunc, u8 gamma, u8 aniso_bias, u8 signed_remap)
+	// Control0
-	{
+	bool IsEnabled() const;
-		m_wraps = wraps;
+	u16  GetMinLOD() const;
-		m_wrapt = wrapt;
+	u16  GetMaxLOD() const;
-		m_wrapr = wrapr;
+	u8   GetMaxAniso() const;
-		m_unsigned_remap = unsigned_remap;
+	bool IsAlphaKillEnabled() const;
-		m_zfunc = zfunc;
-		m_gamma = gamma;
-		m_aniso_bias = aniso_bias;
-		m_signed_remap = signed_remap;
-	}
 
-	void SetControl0(const bool enable, const u16 minlod, const u16 maxlod, const u8 maxaniso)
+	// Control1
-	{
+	u32 GetRemap() const;
-		m_enabled = enable;
-		m_minlod = minlod;
-		m_maxlod = maxlod;
-		m_maxaniso = maxaniso;
-	}
 
-	void SetControl1(u32 remap)
+	// Filter
-	{
+	u16 GetBias() const;
-		m_remap = remap;
+	u8  GetMinFilter() const;
-	}
+	u8  GetMagFilter() const;
+	u8  GetConvolutionFilter() const;
+	bool isASigned() const;
+	bool isRSigned() const;
+	bool isGSigned() const;
+	bool isBSigned() const;
 
-	void SetControl3(u16 depth, u32 pitch)
+	// Image Rect
-	{
+	u16 GetWidth() const;
-		m_depth = depth;
+	u16 GetHeight() const;
-		m_pitch = pitch;
-	}
 
-	void SetFilter(u16 bias, u8 min, u8 mag, u8 conv, u8 a_signed, u8 r_signed, u8 g_signed, u8 b_signed)
+	void SetControl3(u16 depth, u32 pitch);
-	{
-		m_bias = bias;
-		m_min_filter = min;
-		m_mag_filter = mag;
-		m_conv = conv;
-		m_a_signed = a_signed;
-		m_r_signed = r_signed;
-		m_g_signed = g_signed;
-		m_b_signed = b_signed;
-	}
-
-	u32 GetFormat() const
-	{
-		return m_format;
-	}
-
-	void SetOffset(const u32 offset)
-	{
-		m_offset = offset;
-	}
-
-	wxSize GetRect() const
-	{
-		return wxSize(m_width, m_height);
-	}
-
-	bool IsEnabled() const
-	{
-		return m_enabled;
-	}
-
-	u32 GetOffset() const
-	{
-		return m_offset;
-	}
 };
 
 struct RSXVertexData
@@ -561,6 +484,12 @@ protected:
 		m_point_x = 0;
 		m_point_y = 0;
 
+    // Construct Textures
+    for(int i=0; i<16; i++)
+    {
+      m_textures[i] = RSXTexture(i);
+    }
+
 		Reset();
 	}
 
@@ -619,6 +548,11 @@ protected:
 
 		m_clear_surface_mask = 0;
 		m_begin_end = 0;
+
+    for(uint i=0; i<m_textures_count; ++i)
+	  {
+			m_textures[i].Init();
+	  }
 	}
 
 	void Begin(u32 draw_mode);
@@ -633,19 +567,6 @@ protected:
 	virtual void ExecCMD() = 0;
 	virtual void Flip() = 0;
 
-	u32 GetAddress(u32 offset, u8 location)
-	{
-		switch(location)
-		{
-		case CELL_GCM_LOCATION_LOCAL: return m_local_mem_addr + offset;
-		case CELL_GCM_LOCATION_MAIN: return Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + offset);
-		}
-
-		ConLog.Error("GetAddress(offset=0x%x, location=0x%x)", location);
-		assert(0);
-		return 0;
-	}
-
 	void LoadVertexData(u32 first, u32 count)
 	{
 		for(u32 i=0; i<m_vertex_count; ++i)

rpcs3/Emu/HDD/HDD.cpp

@@ -1,3 +1,16 @@
 #include "stdafx.h"
 #include "HDD.h"
 
+vfsDeviceHDD::vfsDeviceHDD(const std::string& hdd_path) : m_hdd_path(hdd_path)
+{
+}
+
+vfsFileBase* vfsDeviceHDD::GetNewFileStream()
+{
+	return new vfsHDD(this, m_hdd_path);
+}
+
+vfsDirBase* vfsDeviceHDD::GetNewDirStream()
+{
+	return nullptr;
+}

rpcs3/Emu/HDD/HDD.h

@@ -262,7 +262,7 @@ public:
 		if(!size)
 			return 0;
 
-		vfsDeviceLocker lock(m_hdd);
+		//vfsDeviceLocker lock(m_hdd);
 
 		const u32 block_size = m_hdd_info.block_size - sizeof(vfsHDD_Block);
 		u64 rsize = min<u64>(block_size - m_position, size);
@@ -310,7 +310,7 @@ public:
 		if(!size)
 			return 0;
 
-		vfsDeviceLocker lock(m_hdd);
+		//vfsDeviceLocker lock(m_hdd);
 
 		const u32 block_size = m_hdd_info.block_size - sizeof(vfsHDD_Block);
 
@@ -409,6 +409,17 @@ public:
 	}
 };
 
+class vfsDeviceHDD : public vfsDevice
+{
+	std::string m_hdd_path;
+
+public:
+	vfsDeviceHDD(const std::string& hdd_path);
+
+	virtual vfsFileBase* GetNewFileStream() override;
+	virtual vfsDirBase* GetNewDirStream() override;
+};
+
 class vfsHDD : public vfsFileBase
 {
 	vfsHDD_Hdr m_hdd_info;
@@ -419,11 +430,13 @@ class vfsHDD : public vfsFileBase
 	const wxString& m_hdd_path;
 
 public:
-	vfsHDD(const wxString& hdd_path)
+	vfsHDD(vfsDevice* device, const wxString& hdd_path)
-		: m_hdd_file(hdd_path, vfsReadWrite)
+		: m_hdd_file(device)
 		, m_file(m_hdd_file, m_hdd_info)
 		, m_hdd_path(hdd_path)
+		, vfsFileBase(device)
 	{
+		m_hdd_file.Open(hdd_path, vfsReadWrite);
 		m_hdd_file.Read(&m_hdd_info, sizeof(vfsHDD_Hdr));
 		m_cur_dir_block = m_hdd_info.next_block;
 		if(!m_hdd_info.block_size)
@@ -435,11 +448,6 @@ public:
 		m_hdd_file.Read(&m_cur_dir, sizeof(vfsHDD_Entry));
 	}
 
-	virtual vfsDevice* GetNew()
-	{
-		return new vfsHDD(m_hdd_path);
-	}
-
 	__forceinline u32 GetMaxNameLen() const
 	{
 		return m_hdd_info.block_size - sizeof(vfsHDD_Entry);
@@ -861,4 +869,4 @@ public:
 	{
 		return m_file.GetSize();
 	}
-};
+};

rpcs3/Emu/SysCalls/Modules/cellAudio.cpp

@@ -450,7 +450,7 @@ int cellAudioPortStart(u32 portNum)
 
 			const u32 block_size = port.m_param.nChannel * 256 * sizeof(float);
 
-			u32 buffer[32*256]; // buffer for max channel count (8)
+			float buffer[32*256]; // buffer for max channel count (8)
 
 			while (port.m_is_audio_port_started)
 			{
@@ -471,7 +471,8 @@ int cellAudioPortStart(u32 portNum)
 
 				for (u32 i = 0; i < block_size; i++)
 				{
-					buffer[i] = re(buffer[i]); // reverse byte order
+					// reverse byte order (TODO: use port.m_param.level)
+					buffer[i] = re(buffer[i]);
 				}
 
 				output.Write(&buffer, block_size); // write file data
@@ -480,7 +481,7 @@ int cellAudioPortStart(u32 portNum)
 				
 				if (Emu.IsStopped())
 				{
-					ConLog.Warning("Port aborted");
+					ConLog.Write("Port aborted");
 					goto abort;
 				}
 			}

rpcs3/Emu/SysCalls/Modules/cellFont.cpp

@@ -509,7 +509,7 @@ int cellFontBindRenderer(mem_ptr_t<CellFont> font, mem_ptr_t<CellFontRenderer> r
 	cellFont.Warning("cellFontBindRenderer(font_addr=0x%x, renderer_addr=0x%x)",
 		font.GetAddr(), renderer.GetAddr());
 	
-	if (!font.IsGood() || !renderer.GetAddr())
+	if (!font.IsGood() || !renderer.IsGood())
 		return CELL_FONT_ERROR_INVALID_PARAMETER;
 	if (font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_ALREADY_BIND;
@@ -592,11 +592,11 @@ int cellFontRenderCharGlyphImage(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<C
 
 	// Move the rendered character to the surface
 	unsigned char* buffer = (unsigned char*)Memory.VirtualToRealAddr(surface->buffer_addr);
-	for (u32 ypos = 0; ypos < height; ypos++){
+	for (u32 ypos = 0; ypos < (u32)height; ypos++){
 		if ((u32)y + ypos + yoff + baseLineY >= surface->height)
 			break;
 
-		for (u32 xpos = 0; xpos < width; xpos++){
+		for (u32 xpos = 0; xpos < (u32)width; xpos++){
 			if ((u32)x + xpos >= surface->width)
 				break;
 

rpcs3/Emu/SysCalls/Modules/cellGame.cpp

@@ -123,7 +123,7 @@ int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameConten
 	type				= CELL_GAME_GAMETYPE_DISC;
 	attributes			= 0;
 	size->hddFreeSizeKB = 40000000; //40 GB, TODO: Use the free space of the computer's HDD where RPCS3 is being run.
-	size->sizeKB		= 0;
+	size->sizeKB		= CELL_GAME_SIZEKB_NOTCALC;
 	size->sysSizeKB		= 0;
 	Memory.WriteString(dirName.GetAddr(), dir);
 
@@ -150,8 +150,6 @@ int cellGameContentPermit(mem_list_ptr_t<u8> contentInfoPath,  mem_list_ptr_t<u8
 	if (!contentInfoPath.IsGood() || !usrdirPath.IsGood())
 		return CELL_GAME_ERROR_PARAM;
 	
-	Memory.WriteString(contentInfoPath.GetAddr(), "/dev_bdvd/PS3_GAME");
-	Memory.WriteString(usrdirPath.GetAddr(), "/dev_bdvd/PS3_GAME/USRDIR");
 	return CELL_OK;
 }
 

rpcs3/Emu/SysCalls/Modules/cellResc.cpp

@@ -609,9 +609,9 @@ int cellRescGetBufferSize(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fra
 		fragmentUcodeSize = 0x300;
 	}
 
-	if(colorBuffers.GetAddr())   colorBuffers = colorBuffersSize;
+	if(colorBuffers.IsGood())   colorBuffers = colorBuffersSize;
-	if(vertexArray.GetAddr())    vertexArray = vertexArraySize;
+	if(vertexArray.IsGood())    vertexArray = vertexArraySize;
-	if(fragmentShader.GetAddr()) fragmentShader = fragmentUcodeSize;
+	if(fragmentShader.IsGood()) fragmentShader = fragmentUcodeSize;
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp

@@ -117,6 +117,20 @@ enum
 	CELL_MSGDIALOG_BUTTON_ESCAPE	= 3,
 };
 
+enum{
+	CELL_SYSCACHE_RET_OK_CLEARED		= 0,
+	CELL_SYSCACHE_RET_OK_RELAYED		= 1, 
+
+	CELL_SYSCACHE_ID_SIZE				= 32,	
+	CELL_SYSCACHE_PATH_MAX				= 1055,
+
+	CELL_SYSCACHE_ERROR_ACCESS_ERROR	= 0x8002bc01,//I don't think we need this
+	CELL_SYSCACHE_ERROR_INTERNAL		= 0x8002bc02,//not really useful, if we run out of HD space sysfs should handle that
+
+	CELL_SYSCACHE_ERROR_PARAM			= 0x8002bc03,
+	CELL_SYSCACHE_ERROR_NOTMOUNTED		= 0x8002bc04,//we don't really need to simulate the mounting, so this is probably useless
+};
+
 enum CellMsgDialogType
 {
 	CELL_MSGDIALOG_DIALOG_TYPE_ERROR	= 0x00000000,
@@ -894,6 +908,73 @@ int cellAudioOutSetCopyControl(u32 audioOut, u32 control)
 	return CELL_AUDIO_OUT_SUCCEEDED;
 }
 
+
+
+
+typedef struct{
+	char cacheId[CELL_SYSCACHE_ID_SIZE];
+	char getCachePath[CELL_SYSCACHE_PATH_MAX];
+	mem_ptr_t<void> reserved;
+} CellSysCacheParam;
+
+
+class WxDirDeleteTraverser : public wxDirTraverser
+{
+public:
+	virtual wxDirTraverseResult OnFile(const wxString& filename)
+	{
+		if (!wxRemoveFile(filename)){
+			cellSysutil.Error("Couldn't delete File: %s", filename.wx_str());
+		}
+		return wxDIR_CONTINUE;
+	}
+	virtual wxDirTraverseResult OnDir(const wxString& dirname)
+	{
+		wxDir dir(dirname);
+		dir.Traverse(*this);
+		if (!wxRmDir(dirname)){
+		//this get triggered a few times while clearing folders
+		//but if this gets reimplented we should probably warn
+		//if directories can't be removed
+		}
+		return wxDIR_CONTINUE;
+	}
+};
+
+int cellSysCacheClear(void)
+{
+	//if some software expects CELL_SYSCACHE_ERROR_NOTMOUNTED we need to check whether
+	//it was mounted before, for that we would need to save the state which I don't know
+	//where to put
+	wxString localPath;
+	Emu.GetVFS().GetDevice(wxString("/dev_hdd1/cache/"), localPath);
+	if (wxDirExists(localPath)){
+		WxDirDeleteTraverser deleter;
+		wxString f = wxFindFirstFile(localPath+"\\*",wxDIR);
+		while (!f.empty())
+		{
+			wxDir dir(f);
+			dir.Traverse(deleter);
+			f = wxFindNextFile();
+		}
+		return CELL_SYSCACHE_RET_OK_CLEARED;
+	}
+	else{
+		return CELL_SYSCACHE_ERROR_ACCESS_ERROR;
+	}
+}
+
+int cellSysCacheMount(mem_ptr_t<CellSysCacheParam> param)
+{
+	//TODO: implement
+	char id[CELL_SYSCACHE_ID_SIZE];
+	strncpy(id, param->cacheId, CELL_SYSCACHE_ID_SIZE);
+	strncpy(param->getCachePath, ("/dev_hdd1/cache/" + std::string(id) + "/").c_str(), CELL_SYSCACHE_PATH_MAX);
+	Emu.GetVFS().CreateFile(wxString(param->getCachePath));
+
+	return CELL_SYSCACHE_RET_OK_RELAYED;
+}
+
 void cellSysutil_init()
 {
 	cellSysutil.AddFunc(0x40e895d3, cellSysutilGetSystemParamInt);
@@ -922,4 +1003,8 @@ void cellSysutil_init()
 	cellSysutil.AddFunc(0xe5e2b09d, cellAudioOutGetNumberOfDevice);
 	cellSysutil.AddFunc(0xed5d96af, cellAudioOutGetConfiguration);
 	cellSysutil.AddFunc(0xc96e89e9, cellAudioOutSetCopyControl);
+
+	cellSysutil.AddFunc(0x1e7bff94, cellSysCacheMount);
+	cellSysutil.AddFunc(0x744c1544, cellSysCacheClear);
+
 }

rpcs3/Emu/SysCalls/Modules/sceNp.cpp

@@ -0,0 +1,12 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+#include "sceNp.h"
+
+void sceNp_init();
+Module sceNp(0x0016, sceNpTrophy_init);
+
+void sceNpTrophy_init()
+{
+}

rpcs3/Emu/SysCalls/Modules/sceNp.h

@@ -0,0 +1,26 @@
+#pragma once
+
+// Return Codes
+enum
+{
+};
+
+enum
+{
+	SCE_NP_COMMUNICATION_SIGNATURE_SIZE      = 160,
+	SCE_NET_NP_COMMUNICATION_PASSPHRASE_SIZE = 128,
+};
+
+// Structs
+struct SceNpCommunicationId
+{
+	char data[9];
+	char term;
+	u8 num;
+	char dummy;
+};
+
+struct SceNpCommunicationSignature
+{
+	uint8_t data[SCE_NP_COMMUNICATION_SIGNATURE_SIZE];
+};

rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp

@@ -0,0 +1,281 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+#include "sceNp.h"
+#include "Loader/TRP.h"
+
+void sceNpTrophy_unload();
+void sceNpTrophy_init();
+Module sceNpTrophy(0xf035, sceNpTrophy_init, nullptr, sceNpTrophy_unload);
+
+enum
+{
+	SCE_NP_TROPHY_ERROR_ALREADY_INITIALIZED      = 0x80022901,
+	SCE_NP_TROPHY_ERROR_NOT_INITIALIZED          = 0x80022902,
+	SCE_NP_TROPHY_ERROR_NOT_SUPPORTED            = 0x80022903,
+	SCE_NP_TROPHY_ERROR_CONTEXT_NOT_REGISTERED   = 0x80022904,
+	SCE_NP_TROPHY_ERROR_OUT_OF_MEMORY            = 0x80022905,
+	SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT         = 0x80022906,
+	SCE_NP_TROPHY_ERROR_EXCEEDS_MAX              = 0x80022907,
+	SCE_NP_TROPHY_ERROR_INSUFFICIENT             = 0x80022909,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_CONTEXT          = 0x8002290a,
+	SCE_NP_TROPHY_ERROR_INVALID_FORMAT           = 0x8002290b,
+	SCE_NP_TROPHY_ERROR_BAD_RESPONSE             = 0x8002290c,
+	SCE_NP_TROPHY_ERROR_INVALID_GRADE            = 0x8002290d,
+	SCE_NP_TROPHY_ERROR_INVALID_CONTEXT          = 0x8002290e,
+	SCE_NP_TROPHY_ERROR_PROCESSING_ABORTED       = 0x8002290f,
+	SCE_NP_TROPHY_ERROR_ABORT                    = 0x80022910,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE           = 0x80022911,
+	SCE_NP_TROPHY_ERROR_LOCKED                   = 0x80022912,
+	SCE_NP_TROPHY_ERROR_HIDDEN                   = 0x80022913,
+	SCE_NP_TROPHY_ERROR_CANNOT_UNLOCK_PLATINUM   = 0x80022914,
+	SCE_NP_TROPHY_ERROR_ALREADY_UNLOCKED         = 0x80022915,
+	SCE_NP_TROPHY_ERROR_INVALID_TYPE             = 0x80022916,
+	SCE_NP_TROPHY_ERROR_INVALID_HANDLE           = 0x80022917,
+	SCE_NP_TROPHY_ERROR_INVALID_NP_COMM_ID       = 0x80022918,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_NP_COMM_ID       = 0x80022919,
+	SCE_NP_TROPHY_ERROR_DISC_IO                  = 0x8002291a,
+	SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST      = 0x8002291b,
+	SCE_NP_TROPHY_ERROR_UNSUPPORTED_FORMAT       = 0x8002291c,
+	SCE_NP_TROPHY_ERROR_ALREADY_INSTALLED        = 0x8002291d,
+	SCE_NP_TROPHY_ERROR_BROKEN_DATA              = 0x8002291e,
+	SCE_NP_TROPHY_ERROR_VERIFICATION_FAILURE     = 0x8002291f,
+	SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID        = 0x80022920,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_TROPHY_ID        = 0x80022921,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_TITLE            = 0x80022922,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_FILE             = 0x80022923,
+	SCE_NP_TROPHY_ERROR_DISC_NOT_MOUNTED         = 0x80022924,
+	SCE_NP_TROPHY_ERROR_SHUTDOWN                 = 0x80022925,
+	SCE_NP_TROPHY_ERROR_TITLE_ICON_NOT_FOUND     = 0x80022926,
+	SCE_NP_TROPHY_ERROR_TROPHY_ICON_NOT_FOUND    = 0x80022927,
+	SCE_NP_TROPHY_ERROR_INSUFFICIENT_DISK_SPACE  = 0x80022928,
+	SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE           = 0x8002292a,
+	SCE_NP_TROPHY_ERROR_SAVEDATA_USER_DOES_NOT_MATCH = 0x8002292b,
+	SCE_NP_TROPHY_ERROR_TROPHY_ID_DOES_NOT_EXIST = 0x8002292c,
+	SCE_NP_TROPHY_ERROR_SERVICE_UNAVAILABLE      = 0x8002292d,
+	SCE_NP_TROPHY_ERROR_UNKNOWN                  = 0x800229ff,
+};
+
+
+struct sceNpTrophyInternalContext
+{
+	// TODO
+	std::string trp_name;
+	vfsStream* trp_stream;
+};
+
+struct sceNpTrophyInternal
+{
+	bool m_bInitialized;
+	std::vector<sceNpTrophyInternalContext> contexts;
+
+	sceNpTrophyInternal()
+		: m_bInitialized(false)
+	{
+	}
+};
+
+sceNpTrophyInternal s_npTrophyInstance;
+
+// Functions
+int sceNpTrophyInit(u32 pool_addr, u32 poolSize, u32 containerId, u64 options)
+{
+	sceNpTrophy.Log("sceNpTrophyInit(pool_addr=0x%x, poolSize=%d, containerId=%d, options=0x%llx)", pool_addr, poolSize, containerId, options);
+
+	if (s_npTrophyInstance.m_bInitialized)
+		return SCE_NP_TROPHY_ERROR_ALREADY_INITIALIZED;
+	if (options)
+		return SCE_NP_TROPHY_ERROR_NOT_SUPPORTED;
+
+	s_npTrophyInstance.m_bInitialized = true;
+	return CELL_OK;
+}
+
+int sceNpTrophyCreateContext(mem32_t context, mem_ptr_t<SceNpCommunicationId> commID, mem_ptr_t<SceNpCommunicationSignature> commSign, u64 options)
+{
+	sceNpTrophy.Warning("sceNpTrophyCreateContext(context_addr=0x%x, commID_addr=0x%x, commSign_addr=0x%x, options=0x%llx)",
+		context.GetAddr(), commID.GetAddr(), commSign.GetAddr(), options);
+
+	if (!s_npTrophyInstance.m_bInitialized)
+		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
+	if (!context.IsGood())
+		return SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT;
+	if (options & (~(u64)1))
+		SCE_NP_TROPHY_ERROR_NOT_SUPPORTED;
+	// TODO: There are other possible errors
+
+	// TODO: Is the TROPHY.TRP file necessarily located in this path?
+	vfsDir dir("/app_home/TROPDIR/");
+	if(!dir.IsOpened())
+		return SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST;
+
+	// TODO: Following method will retrieve the TROPHY.TRP of the first folder that contains such file
+	for(const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
+	{
+		if (entry->flags & DirEntry_TypeDir)
+		{
+			std::shared_ptr<vfsFileBase> f(Emu.GetVFS().OpenFile("/app_home/TROPDIR/" + entry->name + "/TROPHY.TRP", vfsRead));
+
+			if (f && f->IsOpened())
+			{
+				sceNpTrophyInternalContext ctxt;
+				ctxt.trp_stream = f.get();
+				ctxt.trp_name = entry->name;
+				s_npTrophyInstance.contexts.push_back(ctxt);
+				f = nullptr;
+				return CELL_OK;
+			}
+		}
+	}
+
+	return SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST;
+}
+
+int sceNpTrophyCreateHandle(mem32_t handle)
+{
+	sceNpTrophy.Warning("sceNpTrophyCreateHandle(handle_addr=0x%x)", handle.GetAddr());
+
+	if (!s_npTrophyInstance.m_bInitialized)
+		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
+	if (!handle.IsGood())
+		return SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT;
+	// TODO: There are other possible errors
+
+	// TODO: ?
+
+	return CELL_OK;
+}
+
+int sceNpTrophyRegisterContext(u32 context, u32 handle, u32 statusCb_addr, u32 arg_addr, u64 options)
+{
+	sceNpTrophy.Warning("sceNpTrophyRegisterContext(context=%d, handle=%d, statusCb_addr=0x%x, arg_addr=0x%x, options=0x%llx)",
+		context, handle, statusCb_addr, arg_addr, options);
+
+	if (!(s_npTrophyInstance.m_bInitialized))
+		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
+	if (!Memory.IsGoodAddr(statusCb_addr))
+		return SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT;
+	if (options & (~(u64)1))
+		SCE_NP_TROPHY_ERROR_NOT_SUPPORTED;
+	// TODO: There are other possible errors
+
+	int ret;
+	sceNpTrophyInternalContext& ctxt = s_npTrophyInstance.contexts[context];
+	TRPLoader trp(*(ctxt.trp_stream));
+
+	// TODO: Get the path of the current user
+	if (trp.Install("/dev_hdd0/home/00000001/trophy/" + ctxt.trp_name))
+		ret = CELL_OK;
+	else
+		ret = SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE;
+	
+	// TODO: Callbacks
+	
+	trp.Close();
+	return ret;
+}
+
+int sceNpTrophyGetGameProgress()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophySetSoundLevel()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyGetRequiredDiskSpace()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyDestroyContext()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyAbortHandle()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyGetGameInfo()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyDestroyHandle()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyUnlockTrophy()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyTerm()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyGetTrophyUnlockState()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyGetTrophyIcon()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyGetTrophyInfo()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+int sceNpTrophyGetGameIcon()
+{
+	UNIMPLEMENTED_FUNC(sceNpTrophy);
+	return CELL_OK;
+}
+
+void sceNpTrophy_unload()
+{
+	s_npTrophyInstance.m_bInitialized = false;
+}
+
+void sceNpTrophy_init()
+{
+	sceNpTrophy.AddFunc(0x079f0e87, sceNpTrophyGetGameProgress);
+	sceNpTrophy.AddFunc(0x1197b52c, sceNpTrophyRegisterContext);
+	sceNpTrophy.AddFunc(0x1c25470d, sceNpTrophyCreateHandle);
+	sceNpTrophy.AddFunc(0x27deda93, sceNpTrophySetSoundLevel);
+	sceNpTrophy.AddFunc(0x370136fe, sceNpTrophyGetRequiredDiskSpace);
+	sceNpTrophy.AddFunc(0x3741ecc7, sceNpTrophyDestroyContext);
+	sceNpTrophy.AddFunc(0x39567781, sceNpTrophyInit);
+	sceNpTrophy.AddFunc(0x48bd97c7, sceNpTrophyAbortHandle);
+	sceNpTrophy.AddFunc(0x49d18217, sceNpTrophyGetGameInfo);
+	sceNpTrophy.AddFunc(0x623cd2dc, sceNpTrophyDestroyHandle);
+	sceNpTrophy.AddFunc(0x8ceedd21, sceNpTrophyUnlockTrophy);
+	sceNpTrophy.AddFunc(0xa7fabf4d, sceNpTrophyTerm);
+	sceNpTrophy.AddFunc(0xb3ac3478, sceNpTrophyGetTrophyUnlockState);
+	sceNpTrophy.AddFunc(0xbaedf689, sceNpTrophyGetTrophyIcon);
+	sceNpTrophy.AddFunc(0xe3bf9a28, sceNpTrophyCreateContext);
+	sceNpTrophy.AddFunc(0xfce6d30a, sceNpTrophyGetTrophyInfo);
+	sceNpTrophy.AddFunc(0xff299e03, sceNpTrophyGetGameIcon);
+}

rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp

@@ -183,4 +183,8 @@ void sysPrxForUser_init()
 	sysPrxForUser.AddFunc(0xe9a1bd84, sys_lwcond_signal_all);
 	sysPrxForUser.AddFunc(0x52aadadf, sys_lwcond_signal_to);
 	sysPrxForUser.AddFunc(0x2a6d9d51, sys_lwcond_wait);
+
+	sysPrxForUser.AddFunc(0x67f9fedb, sys_game_process_exitspawn2);
+	sysPrxForUser.AddFunc(0xfc52a7a9, sys_game_process_exitspawn);
+
 }

rpcs3/Emu/SysCalls/Modules/sys_fs.cpp

@@ -33,20 +33,18 @@ bool sdata_check(u32 version, u32 flags, u64 filesizeInput, u64 filesizeTmp)
 
 int sdata_unpack(wxString packed_file, wxString unpacked_file)
 {
-	vfsStream* packed_stream = Emu.GetVFS().Open(packed_file, vfsRead);
+	std::shared_ptr<vfsFileBase> packed_stream(Emu.GetVFS().OpenFile(packed_file, vfsRead));
-	vfsStream* unpacked_stream = Emu.GetVFS().Open(unpacked_file, vfsWrite);
+	std::shared_ptr<vfsFileBase> unpacked_stream(Emu.GetVFS().OpenFile(unpacked_file, vfsWrite));
 	
 	if(!packed_stream || !packed_stream->IsOpened())
 	{
 		sys_fs.Error("'%s' not found! flags: 0x%08x", packed_file.wx_str(), vfsRead);
-		delete packed_stream;
 		return CELL_ENOENT;
 	}
 
 	if(!unpacked_stream || !unpacked_stream->IsOpened())
 	{
 		sys_fs.Error("'%s' couldn't be created! flags: 0x%08x", unpacked_file.wx_str(), vfsWrite);
-		delete unpacked_stream;
 		return CELL_ENOENT;
 	}
 
@@ -103,9 +101,6 @@ int sdata_unpack(wxString packed_file, wxString unpacked_file)
 		}
 	}
 
-	packed_stream->Close();
-	unpacked_stream->Close();
-
 	return CELL_OK;
 }
 	
@@ -129,8 +124,7 @@ int cellFsSdataOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 	int ret = sdata_unpack(path, unpacked_path);
 	if (ret) return ret;
 
-	vfsStream* stream = Emu.GetVFS().Open(unpacked_path, vfsRead);
+	fd = sys_fs.GetNewId(Emu.GetVFS().OpenFile(unpacked_path, vfsRead), flags);
-	fd = sys_fs.GetNewId(stream, flags);
 
 	return CELL_OK;
 }
@@ -265,5 +259,6 @@ void sys_fs_init()
 	sys_fs.AddFunc(0xc1c507e7, cellFsAioRead);
 	sys_fs.AddFunc(0xdb869f20, cellFsAioInit);
 	sys_fs.AddFunc(0x9f951810, cellFsAioFinish);
+	sys_fs.AddFunc(0x1a108ab7, cellFsGetBlockSize);
 	aio_init = false;
 }

rpcs3/Emu/SysCalls/SysCalls.h

@@ -122,8 +122,10 @@ extern int sys_process_get_number_of_object(u32 object, mem32_t nump);
 extern int sys_process_get_id(u32 object, mem8_ptr_t buffer, u32 size, mem32_t set_size);
 extern int sys_process_get_paramsfo(mem8_ptr_t buffer);
 extern int sys_process_exit(int errorcode);
-extern int sys_game_process_exitspawn(u32 path_addr, u32 argv_addr, u32 envp_addr,
+extern void sys_game_process_exitspawn(u32 path_addr, u32 argv_addr, u32 envp_addr,
-								u32 data, u32 data_size, int prio, u64 flags );
+								u32 data_addr, u32 data_size, u32 prio, u64 flags );
+extern void sys_game_process_exitspawn2(u32 path_addr, u32 argv_addr, u32 envp_addr,
+								u32 data_addr, u32 data_size, u32 prio, u64 flags);
 
 //sys_event
 extern int sys_event_queue_create(mem32_t equeue_id, mem_ptr_t<sys_event_queue_attr> attr, u64 event_queue_key, int size);
@@ -254,6 +256,7 @@ extern int cellFsLseek(u32 fd, s64 offset, u32 whence, mem64_t pos);
 extern int cellFsFtruncate(u32 fd, u64 size);
 extern int cellFsTruncate(u32 path_addr, u64 size);
 extern int cellFsFGetBlockSize(u32 fd, mem64_t sector_size, mem64_t block_size);
+extern int cellFsGetBlockSize(u32 path_addr, mem64_t sector_size, mem64_t block_size);
 
 //cellVideo
 extern int cellVideoOutGetState(u32 videoOut, u32 deviceIndex, u32 state_addr);
@@ -304,8 +307,8 @@ extern int cellMouseGetRawData(u32 port_no, mem_class_t data);
 extern int cellGcmCallback(u32 context_addr, u32 count);
 
 //sys_tty
-extern int sys_tty_read(s32 ch, u64 buf_addr, u32 len, u64 preadlen_addr);
+extern int sys_tty_read(u32 ch, u64 buf_addr, u32 len, u64 preadlen_addr);
-extern int sys_tty_write(s32 ch, u64 buf_addr, u32 len, u64 pwritelen_addr);
+extern int sys_tty_write(u32 ch, u64 buf_addr, u32 len, u64 pwritelen_addr);
 
 //sys_heap
 extern int sys_heap_create_heap(const u32 heap_addr, const u32 start_addr, const u32 size);

rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp

@@ -17,7 +17,7 @@ int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 	if(flags & CELL_O_CREAT)
 	{
 		_oflags &= ~CELL_O_CREAT;
-		Emu.GetVFS().Create(ppath);
+		Emu.GetVFS().CreateFile(ppath);
 	}
 
 	vfsOpenMode o_mode;
@@ -42,7 +42,7 @@ int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 			_oflags &= ~CELL_O_EXCL;
 			o_mode = vfsWriteExcl;
 		}
-		else //if(flags & CELL_O_TRUNC)
+		else //if (flags & CELL_O_TRUNC)
 		{
 			_oflags &= ~CELL_O_TRUNC;
 			o_mode = vfsWrite;
@@ -51,6 +51,12 @@ int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 
 	case CELL_O_RDWR:
 		_oflags &= ~CELL_O_RDWR;
+		if (flags & CELL_O_TRUNC)
+		{
+			_oflags &= ~CELL_O_TRUNC;
+			//truncate file before opening it as read/write
+			Emu.GetVFS().OpenFile(ppath, vfsWrite);
+		}
 		o_mode = vfsReadWrite;
 	break;
 	}
@@ -61,13 +67,11 @@ int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 		return CELL_EINVAL;
 	}
 
-	vfsStream* stream = Emu.GetVFS().Open(ppath, o_mode);
+	vfsFileBase* stream = Emu.GetVFS().OpenFile(ppath, o_mode);
 
 	if(!stream || !stream->IsOpened())
 	{
 		sys_fs.Error("\"%s\" not found! flags: 0x%08x", ppath.wx_str(), flags);
-		delete stream;
-
 		return CELL_ENOENT;
 	}
 
@@ -137,11 +141,12 @@ int cellFsOpendir(u32 path_addr, mem32_t fd)
 	if(!Memory.IsGoodAddr(path_addr) || !fd.IsGood())
 		return CELL_EFAULT;
 
-	wxString localPath;
+	vfsDirBase* dir = Emu.GetVFS().OpenDir(path);
-	Emu.GetVFS().GetDevice(path, localPath);
+	if(!dir || !dir->IsOpened())
-	vfsLocalDir* dir = new vfsLocalDir(localPath);
+	{
-	if(!dir->Open(localPath))
+		delete dir;
 		return CELL_ENOENT;
+	}
 
 	fd = sys_fs.GetNewId(dir);
 	return CELL_OK;
@@ -163,7 +168,7 @@ int cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, mem64_t nread)
 		nread = 1;
 		Memory.WriteString(dir.GetAddr()+2, info->name.wx_str());
 		dir->d_namlen = info->name.Length();
-		dir->d_type = (info->flags & 0x1) ? CELL_FS_TYPE_REGULAR : CELL_FS_TYPE_DIRECTORY;
+		dir->d_type = (info->flags & DirEntry_TypeFile) ? CELL_FS_TYPE_REGULAR : CELL_FS_TYPE_DIRECTORY;
 	}
 	else
 	{
@@ -397,3 +402,13 @@ int cellFsFGetBlockSize(u32 fd, mem64_t sector_size, mem64_t block_size)
 
 	return CELL_OK;
 }
+
+int cellFsGetBlockSize(u32 path_addr, mem64_t sector_size, mem64_t block_size)
+{
+	sys_fs.Log("cellFsGetBlockSize(file: %s, sector_size_addr: 0x%x, block_size_addr: 0x%x)", Memory.ReadString(path_addr).wx_str(), sector_size.GetAddr(), block_size.GetAddr());
+
+	sector_size = 4096; // ?
+	block_size = 4096; // ?
+
+	return CELL_OK;
+}

rpcs3/Emu/SysCalls/lv2/SC_Process.cpp

@@ -45,20 +45,103 @@ int sys_process_exit(int errorcode)
 	return CELL_OK;
 }
 
-int sys_game_process_exitspawn(	u32 path_addr, u32 argv_addr, u32 envp_addr,
+void sys_game_process_exitspawn(
-								u32 data, u32 data_size, int prio, u64 flags )
+			u32 path_addr,
+			u32 argv_addr,
+			u32 envp_addr,
+			u32 data_addr,
+			u32 data_size,
+			u32 prio,
+			u64 flags )
 {
-	sc_p.Log("sys_game_process_exitspawn: ");
+	sc_p.Error("sys_game_process_exitspawn UNIMPLEMENTED");
-	sc_p.Log("path: %s", Memory.ReadString(path_addr).wx_str());
+	sc_p.Warning("path: %s", Memory.ReadString(path_addr).wx_str());
-	sc_p.Log("argv: 0x%x", Memory.Read32(argv_addr));
+	sc_p.Warning("argv: 0x%x", argv_addr);
-	sc_p.Log("envp: 0x%x", Memory.Read32(envp_addr));
+	sc_p.Warning("envp: 0x%x", envp_addr);
-	sc_p.Log("data: 0x%x", data);
+	sc_p.Warning("data: 0x%x", data_addr);
-	sc_p.Log("data_size: 0x%x", data_size);
+	sc_p.Warning("data_size: 0x%x", data_size);
-	sc_p.Log("prio: %d", prio);
+	sc_p.Warning("prio: %d", prio);
-	sc_p.Log("flags: %d", flags);
+	sc_p.Warning("flags: %d", flags);
-	return CELL_OK;
+
+	wxString path = Memory.ReadString(path_addr);
+	std::vector<wxString> argv;
+	std::vector<wxString> env;
+
+	mem_ptr_t<u32> argvp(argv_addr);
+	while (argvp.GetAddr() && argvp.IsGood() && *argvp)
+	{
+		argv.push_back(Memory.ReadString(Memory.Read32(argvp.GetAddr())));
+		argvp++;
+	}
+	mem_ptr_t<u32> envp(envp_addr);
+	while (envp.GetAddr() && envp.IsGood() && *envp)
+	{
+		env.push_back(Memory.ReadString(Memory.Read32(envp.GetAddr())));
+		envp++;
+	}
+
+	for (auto &arg : argv){
+		sc_p.Log("argument: %s", arg.wx_str());
+	}
+	for (auto &en : env){
+		sc_p.Log("env_argument: %s", en.wx_str());
+	}
+	//TODO: execute the file in <path> with the args in argv
+	//and the environment parameters in envp and copy the data
+	//from data_addr into the adress space of the new process
+	//then kill the current process
+	return;
 }
 
+void sys_game_process_exitspawn2(
+			u32 path_addr,
+			u32 argv_addr,
+			u32 envp_addr,
+			u32 data_addr,
+			u32 data_size,
+			u32 prio,
+			u64 flags)
+{
+	sc_p.Error("sys_game_process_exitspawn2 UNIMPLEMENTED");
+	sc_p.Warning("path: %s", Memory.ReadString(path_addr).wx_str());
+	sc_p.Warning("argv: 0x%x", argv_addr);
+	sc_p.Warning("envp: 0x%x", envp_addr);
+	sc_p.Warning("data: 0x%x", data_addr);
+	sc_p.Warning("data_size: 0x%x", data_size);
+	sc_p.Warning("prio: %d", prio);
+	sc_p.Warning("flags: %d", flags);
+
+	wxString path = Memory.ReadString(path_addr);
+	std::vector<wxString> argv;
+	std::vector<wxString> env;
+
+	mem_ptr_t<u32> argvp(argv_addr);
+	while (argvp.GetAddr() && argvp.IsGood() && *argvp)
+	{
+		argv.push_back(Memory.ReadString(Memory.Read32(argvp.GetAddr())));
+		argvp++;
+	}
+	mem_ptr_t<u32> envp(envp_addr);
+	while (envp.GetAddr() && envp.IsGood() && *envp)
+	{
+		env.push_back(Memory.ReadString(Memory.Read32(envp.GetAddr())));
+		envp++;
+	}
+
+	for (auto &arg : argv){
+		sc_p.Log("argument: %s", arg.wx_str());
+	}
+	for (auto &en : env){
+		sc_p.Log("env_argument: %s", en.wx_str());
+	}
+	//TODO: execute the file in <path> with the args in argv
+	//and the environment parameters in envp and copy the data
+	//from data_addr into the adress space of the new process
+	//then kill the current process
+	return;
+}
+
+
 int sys_process_get_number_of_object(u32 object, mem32_t nump)
 {
 	sc_p.Warning("TODO: sys_process_get_number_of_object(object=%d, nump_addr=0x%x)",

rpcs3/Emu/SysCalls/lv2/SC_TTY.cpp

@@ -1,17 +1,18 @@
 #include "stdafx.h"
 #include "Emu/SysCalls/SysCalls.h"
 
-int sys_tty_read(s32 ch, u64 buf_addr, u32 len, u64 preadlen_addr)
+int sys_tty_read(u32 ch, u64 buf_addr, u32 len, u64 preadlen_addr)
 {
 	ConLog.Warning("sys_tty_read: ch: %d, buf addr: %llx, len: %d", ch, buf_addr, len);
 	Memory.Write32NN(preadlen_addr, len);
+	Emu.Pause();
 
 	return CELL_OK;
 }
 
-int sys_tty_write(s32 ch, u64 buf_addr, u32 len, u64 pwritelen_addr)
+int sys_tty_write(u32 ch, u64 buf_addr, u32 len, u64 pwritelen_addr)
 {
-	if(ch < 0 || ch > 15 || (s32)len <= 0) return CELL_EINVAL;
+	if(ch > 15 || (s32)len <= 0) return CELL_EINVAL;
 	if(!Memory.IsGoodAddr(buf_addr)) return CELL_EFAULT;
 	
 	Emu.GetDbgCon().Write(ch, Memory.ReadString(buf_addr, len));

rpcs3/Emu/System.cpp

@@ -92,9 +92,9 @@ void Emulator::CheckStatus()
 
 bool Emulator::IsSelf(const std::string& path)
 {
-	vfsLocalFile f(path);
+	vfsLocalFile f(nullptr);
 
-	if(!f.IsOpened())
+	if(!f.Open(path))
 		return false;
 
 	SceHeader hdr;
@@ -238,7 +238,7 @@ void Emulator::Load()
 
 	try
 	{
-		if(!(is_error = !l.Analyze() || l.GetMachine() == MACHINE_Unknown))
+		if(!(is_error = !l.Analyze()) && l.GetMachine() != MACHINE_Unknown)
 		{
 			switch(l.GetMachine())
 			{

rpcs3/Emu/System.h

@@ -107,16 +107,6 @@ public:
 	void SetPath(const wxString& path, const wxString& elf_path = wxEmptyString);
 	void SetTitleID(const wxString& id);
 
-	std::shared_ptr<vfsFileBase> OpenFile(const wxString& path, vfsOpenMode mode = vfsRead)
-	{
-		return std::shared_ptr<vfsFileBase>((vfsFileBase*)m_vfs.Open(path, mode));
-	}
-
-	std::shared_ptr<vfsStream> OpenStream(const wxString& path, vfsOpenMode mode = vfsRead)
-	{
-		return std::shared_ptr<vfsStream>(m_vfs.Open(path, mode));
-	}
-
 	CPUThreadManager&	GetCPU()				{ return m_thread_manager; }
 	PadManager&			GetPadManager()			{ return m_pad_manager; }
 	KeyboardManager&	GetKeyboardManager()	{ return m_keyboard_manager; }

rpcs3/Gui/CompilerELF.cpp

@@ -12,7 +12,7 @@ enum CompilerIDs
 
 wxFont GetFont(int size)
 {
-	return wxFont(size, wxMODERN, wxNORMAL, wxNORMAL);
+	return wxFont(size, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
 }
 
 CompilerELF::CompilerELF(wxWindow* parent)

rpcs3/Gui/DisAsmFrame.cpp

@@ -294,7 +294,9 @@ void DisAsmFrame::Dump(wxCommandEvent& WXUNUSED(event))
 
 	if(ctrl.ShowModal() == wxID_CANCEL) return;
 
-	vfsStream& f_elf = *new vfsLocalFile(Emu.m_path);
+	vfsLocalFile& f_elf = *new vfsLocalFile(nullptr);
+	f_elf.Open(Emu.m_path);
+
 	ConLog.Write("path: %s", Emu.m_path.wx_str());
 	Elf_Ehdr ehdr;
 	ehdr.Load(f_elf);

rpcs3/Gui/GameViewer.cpp

@@ -50,8 +50,10 @@ void GameViewer::LoadPSF()
 	for(uint i=0; i<m_games.GetCount(); ++i)
 	{
 		const wxString& path = m_path + m_games[i] + "\\PARAM.SFO";
-		if(!wxFileExists(path)) continue;
+		vfsLocalFile f(nullptr);
-		vfsLocalFile f(path);
+		if(!f.Open(path))
+			continue;
+
 		PSFLoader psf(f);
 		if(!psf.Load(false)) continue;
 		psf.m_info.root = m_games[i];

rpcs3/Gui/RSXDebugger.cpp

@@ -293,11 +293,13 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
 	if (event.GetId() == p_buffer_colorD->GetId()) SHOW_BUFFER(3);
 	if (event.GetId() == p_buffer_tex->GetId())
 	{
-		if(Memory.IsGoodAddr(render.m_textures[m_cur_texture].m_offset) && render.m_textures[m_cur_texture].m_width && render.m_textures[m_cur_texture].m_height)
+		u8 location = render.m_textures[m_cur_texture].GetLocation();
+		if(location <= 1 && Memory.IsGoodAddr(GetAddress(render.m_textures[m_cur_texture].GetOffset(), location))
+			&& render.m_textures[m_cur_texture].GetWidth() && render.m_textures[m_cur_texture].GetHeight())
 			MemoryViewerPanel::ShowImage(this,
-				render.m_textures[m_cur_texture].m_offset, 0,
+				GetAddress(render.m_textures[m_cur_texture].GetOffset(), location), 1,
-				render.m_textures[m_cur_texture].m_width,
+				render.m_textures[m_cur_texture].GetWidth(),
-				render.m_textures[m_cur_texture].m_height, false);
+				render.m_textures[m_cur_texture].GetHeight(), false);
 	}
 
 #undef SHOW_BUFFER
@@ -417,15 +419,28 @@ void RSXDebugger::GetBuffers()
 	}
 
 	// Draw Texture
-	u32 TexBuffer_addr = render.m_textures[m_cur_texture].m_offset;
+	if(!render.m_textures[m_cur_texture].IsEnabled())
+		return;
+
+	u32 offset = render.m_textures[m_cur_texture].GetOffset();
+
+	if(!offset)
+		return;
+
+	u8 location = render.m_textures[m_cur_texture].GetLocation();
+
+	if(location > 1)
+		return;
+
+	u32 TexBuffer_addr = GetAddress(offset, location);
 
 	if(!Memory.IsGoodAddr(TexBuffer_addr))
 		return;
 
 	unsigned char* TexBuffer = (unsigned char*)Memory.VirtualToRealAddr(TexBuffer_addr);
 
-	u32 width  = render.m_textures[m_cur_texture].m_width;
+	u32 width  = render.m_textures[m_cur_texture].GetWidth();
-	u32 height = render.m_textures[m_cur_texture].m_height;
+	u32 height = render.m_textures[m_cur_texture].GetHeight();
 	unsigned char* buffer = (unsigned char*)malloc(width * height * 3);
 	memcpy(buffer, TexBuffer, width * height * 3);
 
@@ -484,19 +499,32 @@ void RSXDebugger::GetTexture()
 
 	for(uint i=0; i<RSXThread::m_textures_count; ++i)
 	{
-		m_list_texture->InsertItem(i, wxString::Format("%d", i));
+		if(render.m_textures[i].IsEnabled())
-		m_list_texture->SetItem(i, 1, wxString::Format("0x%x", render.m_textures[i].m_offset));
+		{
-		m_list_texture->SetItem(i, 2, render.m_textures[i].m_cubemap ? "True" : "False");
+			m_list_texture->InsertItem(i, wxString::Format("%d", i));
-		m_list_texture->SetItem(i, 3, wxString::Format("%dD", render.m_textures[i].m_dimension));
+			u8 location = render.m_textures[i].GetLocation();
-		m_list_texture->SetItem(i, 4, render.m_textures[i].m_enabled ? "True" : "False");
+			if(location > 1)
-		m_list_texture->SetItem(i, 5, wxString::Format("0x%x", render.m_textures[i].m_format));
+			{
-		m_list_texture->SetItem(i, 6, wxString::Format("0x%x", render.m_textures[i].m_mipmap));
+				m_list_texture->SetItem(i, 1,
-		m_list_texture->SetItem(i, 7, wxString::Format("0x%x", render.m_textures[i].m_pitch));
+					wxString::Format("Bad address (offset=0x%x, location=%d)", render.m_textures[i].GetOffset(), location));
-		m_list_texture->SetItem(i, 8, wxString::Format("%dx%d",
+			}
-			render.m_textures[i].m_width,
+			else
-			render.m_textures[i].m_height));
+			{
+				m_list_texture->SetItem(i, 1, wxString::Format("0x%x", GetAddress(render.m_textures[i].GetOffset(), location)));
+			}
 
-		m_list_texture->SetItemBackgroundColour(i, wxColour(m_cur_texture == i ? "Wheat" : "White"));
+			m_list_texture->SetItem(i, 2, render.m_textures[i].isCubemap() ? "True" : "False");
+			m_list_texture->SetItem(i, 3, wxString::Format("%dD", render.m_textures[i].GetDimension()));
+			m_list_texture->SetItem(i, 4, render.m_textures[i].IsEnabled() ? "True" : "False");
+			m_list_texture->SetItem(i, 5, wxString::Format("0x%x", render.m_textures[i].GetFormat()));
+			m_list_texture->SetItem(i, 6, wxString::Format("0x%x", render.m_textures[i].Getmipmap()));
+			m_list_texture->SetItem(i, 7, wxString::Format("0x%x", render.m_textures[i].m_pitch));
+			m_list_texture->SetItem(i, 8, wxString::Format("%dx%d",
+				render.m_textures[i].GetWidth(),
+				render.m_textures[i].GetHeight()));
+
+			m_list_texture->SetItemBackgroundColour(i, wxColour(m_cur_texture == i ? "Wheat" : "White"));
+		}
 	}
 }
 

rpcs3/Gui/VHDDManager.cpp

@@ -67,7 +67,7 @@ VHDDExplorer::VHDDExplorer(wxWindow* parent, const wxString& hdd_path) : wxDialo
 	m_list->InsertColumn(2, "Size");
 	m_list->InsertColumn(3, "Creation time");
 
-	m_hdd = new vfsHDD(hdd_path);
+	m_hdd = new vfsHDD(nullptr, hdd_path);
 	UpdateList();
 	Connect(m_list->GetId(),	wxEVT_COMMAND_LIST_BEGIN_DRAG,		wxListEventHandler(VHDDExplorer::OnListDrag));
 	Connect(m_list->GetId(),	wxEVT_COMMAND_LIST_ITEM_ACTIVATED,	wxListEventHandler(VHDDExplorer::DClick));

rpcs3/Loader/Loader.cpp

@@ -162,11 +162,13 @@ bool Loader::Load()
 		return false;
 	}
 
+	/*
 	const wxString& root = wxFileName(wxFileName(m_stream->GetPath()).GetPath()).GetPath();
+	wxString ps3_path;
 	const wxString& psf_path = root + "\\" + "PARAM.SFO";
-	if(wxFileExists(psf_path))
+	vfsFile f(psf_path);
+	if(f.IsOpened())
 	{
-		vfsLocalFile f(psf_path);
 		PSFLoader psf_l(f);
 		if(psf_l.Load())
 		{
@@ -175,6 +177,6 @@ bool Loader::Load()
 			psf_l.Close();
 		}
 	}
-
+	*/
 	return true;
 }

rpcs3/Loader/TRP.cpp

@@ -0,0 +1,61 @@
+#include "stdafx.h"
+#include "TRP.h"
+
+TRPLoader::TRPLoader(vfsStream& f) : trp_f(f)
+{
+}
+
+bool TRPLoader::Install(std::string dest, bool show)
+{
+	if(!trp_f.IsOpened()) return false;
+	if(!LoadHeader(show)) return false;
+
+	if (!dest.empty() && dest.back() != '/')
+		dest += '/';
+
+	for (const TRPEntry& entry : m_entries)
+	{
+		char* buffer = new char [entry.size];
+		Emu.GetVFS().CreateFile(dest+entry.name);
+		vfsFile file(dest+entry.name, vfsWrite);
+		trp_f.Seek(entry.offset);
+		trp_f.Read(buffer, entry.size);
+		file.Write(buffer, entry.size);
+		file.Close();
+		delete[] buffer;
+	}
+
+	return true;
+}
+
+bool TRPLoader::Close()
+{
+	return trp_f.Close();
+}
+
+bool TRPLoader::LoadHeader(bool show)
+{
+	trp_f.Seek(0);
+	if (trp_f.Read(&m_header, sizeof(TRPHeader)) != sizeof(TRPHeader))
+		return false;
+
+	if (m_header.trp_magic != 0xDCA24D00)
+		return false;
+
+	if (show)
+		ConLog.Write("TRP version: %x", m_header.trp_version);
+
+	m_entries.clear();
+	m_entries.resize(m_header.trp_files_count);
+
+	for(u32 i=0; i<m_header.trp_files_count; i++)
+	{
+		if (trp_f.Read(&m_entries[i], sizeof(TRPEntry)) != sizeof(TRPEntry))
+			return false;
+
+		if (show)
+			ConLog.Write("TRP entry #%d: %s", wxString(m_entries[i].name).wx_str());
+	}
+
+	return true;
+}

rpcs3/Loader/TRP.h

@@ -0,0 +1,36 @@
+#pragma once
+#include "Loader.h"
+
+struct TRPHeader
+{
+	be_t<u32> trp_magic;
+	be_t<u32> trp_version;
+	be_t<u64> trp_file_size;
+	be_t<u32> trp_files_count;
+	be_t<u32> trp_element_size;
+	be_t<u32> trp_unknown;
+	unsigned char sha1[20];
+	unsigned char padding[16];
+};
+
+struct TRPEntry
+{
+	char name[32];
+	be_t<u64> offset;
+	be_t<u64> size;
+	be_t<u32> unknown;
+	char padding[12];
+};
+
+class TRPLoader
+{
+	vfsStream& trp_f;
+	TRPHeader m_header;
+	std::vector<TRPEntry> m_entries;
+
+public:
+	TRPLoader(vfsStream& f);
+	virtual bool Install(std::string dest, bool show = false);
+	virtual bool LoadHeader(bool show = false);
+	virtual bool Close();
+};

rpcs3/rpcs3.vcxproj

@@ -227,6 +227,8 @@
     <ClCompile Include="Emu\Event.cpp" />
     <ClCompile Include="Emu\FS\VFS.cpp" />
     <ClCompile Include="Emu\FS\vfsDevice.cpp" />
+    <ClCompile Include="Emu\FS\vfsDeviceLocalFile.cpp" />
+    <ClCompile Include="Emu\FS\vfsDir.cpp" />
     <ClCompile Include="Emu\FS\vfsDirBase.cpp" />
     <ClCompile Include="Emu\FS\vfsFile.cpp" />
     <ClCompile Include="Emu\FS\vfsFileBase.cpp" />
@@ -243,6 +245,7 @@
     <ClCompile Include="Emu\GS\GL\OpenGL.cpp" />
     <ClCompile Include="Emu\GS\GSManager.cpp" />
     <ClCompile Include="Emu\GS\GSRender.cpp" />
+    <ClCompile Include="Emu\GS\RSXTexture.cpp" />
     <ClCompile Include="Emu\GS\RSXThread.cpp" />
     <ClCompile Include="Emu\HDD\HDD.cpp" />
     <ClCompile Include="Emu\Io\Keyboard.cpp" />
@@ -292,6 +295,7 @@
     <ClCompile Include="Emu\SysCalls\Modules\cellSysmodule.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellSysutil.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellSysutilAp.cpp" />
+    <ClCompile Include="Emu\SysCalls\Modules\sceNpTrophy.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\sysPrxForUser.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\sys_fs.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\sys_io.cpp" />
@@ -316,6 +320,7 @@
     <ClCompile Include="Loader\Loader.cpp" />
     <ClCompile Include="Loader\PSF.cpp" />
     <ClCompile Include="Loader\SELF.cpp" />
+    <ClCompile Include="Loader\TRP.cpp" />
     <ClCompile Include="rpcs3.cpp" />
     <ClCompile Include="stdafx.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>

rpcs3/rpcs3.vcxproj.filters

@@ -391,6 +391,21 @@
     <ClCompile Include="Emu\Event.cpp">
       <Filter>Emu\SysCalls</Filter>
     </ClCompile>
+    <ClCompile Include="Loader\TRP.cpp">
+      <Filter>Loader</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\GS\RSXTexture.cpp">
+      <Filter>Emu\GS</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\SysCalls\Modules\sceNpTrophy.cpp">
+      <Filter>Emu\SysCalls\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\FS\vfsDeviceLocalFile.cpp">
+      <Filter>Emu\FS</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\FS\vfsDir.cpp">
+      <Filter>Emu\FS</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="rpcs3.rc" />

rpcs3/stdafx.h

@@ -210,9 +210,10 @@ enum Status
 #include "Emu/FS/vfsFileBase.h"
 #include "Emu/FS/vfsLocalDir.h"
 #include "Emu/FS/vfsLocalFile.h"
-#include "Emu/FS/vfsFile.h"
 #include "Emu/FS/vfsStream.h"
 #include "Emu/FS/vfsStreamMemory.h"
+#include "Emu/FS/vfsFile.h"
+#include "Emu/FS/vfsDir.h"
 #include "rpcs3.h"
 
 #define _PRGNAME_ "RPCS3"