RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-22 02:32:36 +01:00
Code Issues Releases Wiki Activity

Fixed conflicts

Browse Source
This commit is contained in:
Nekotekina 2014-02-16 21:57:36 +04:00
commit 931929a82c
62 changed files with 1682 additions and 704 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -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

5
Utilities/Thread.cpp
View File

@ -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;

2
Utilities/Thread.h
View File

@ -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;

44
Utilities/Timer.h
View File

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

1
bin/dev_hdd0/home/00000001/localusername Normal file
View File

@ -0,0 +1 @@
User

4
bin/dev_hdd1/.gitignore vendored
View File

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

1
bin/dev_hdd1/cache/README.txt vendored Normal file
View File

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

193
rpcs3.sln
View File

@ -1,7 +1,5 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.30110.0
MinimumVisualStudioVersion = 10.0.40219.1
# Visual Studio 2012
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

18
rpcs3/Emu/CPU/CPUThread.cpp
View File

@ -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)
{
return CPUThread_Step;
}
if (TestDestroy() || IsPaused())
if(TestDestroy())
{
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);

168
rpcs3/Emu/FS/VFS.cpp
View File

@ -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();
stream->Open(path, mode);
if(vfsFileBase* res = dev->GetNewFileStream())
{
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;
device = nullptr;
wxString path;
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:

18
rpcs3/Emu/FS/VFS.h
View File

@ -36,11 +36,19 @@ struct VFS
void UnMount(const wxString& ps3_path);
void UnMountAll();
vfsStream* Open(const wxString& ps3_path, vfsOpenMode mode);
void Create(const wxString& ps3_path);
void Close(vfsStream*& device);
vfsDevice* GetDevice(const wxString& ps3_path, wxString& path);
vfsDevice* GetDeviceLocal(const wxString& local_path, wxString& path);
vfsFileBase* OpenFile(const wxString& ps3_path, vfsOpenMode mode) const;
vfsDirBase* OpenDir(const wxString& ps3_path) const;
bool CreateFile(const wxString& ps3_path) const;
bool CreateDir(const wxString& ps3_path) const;
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);

20
rpcs3/Emu/FS/vfsDevice.cpp
View File

@ -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)
{

23
rpcs3/Emu/FS/vfsDevice.h
View File

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

14
rpcs3/Emu/FS/vfsDeviceLocalFile.cpp Normal file
View File

@ -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);
}

9
rpcs3/Emu/FS/vfsDeviceLocalFile.h Normal file
View File

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

70
rpcs3/Emu/FS/vfsDir.cpp Normal file
View File

@ -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();
}

25
rpcs3/Emu/FS/vfsDir.h Normal file
View File

@ -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;
};

14
rpcs3/Emu/FS/vfsDirBase.cpp
View File

@ -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++];
}

5
rpcs3/Emu/FS/vfsDirBase.h
View File

@ -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();
};

44
rpcs3/Emu/FS/vfsFile.cpp
View File

@ -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;
return f.Create(path);
bool vfsFile::Exists(const wxString& 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)
{
delete m_stream;
m_stream = nullptr;
return vfsFileBase::Close();
}
return false;
m_stream.reset();
return vfsFileBase::Close();
}
u64 vfsFile::GetSize()

8
rpcs3/Emu/FS/vfsFile.h
View File

@ -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;

4
rpcs3/Emu/FS/vfsFileBase.cpp
View File

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

33
rpcs3/Emu/FS/vfsFileBase.h
View File

@ -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)=0;
virtual bool Exists(const wxString& path)=0;
virtual bool Rename(const wxString& from, const wxString& to)=0;
virtual bool Remove(const wxString& path)=0;
*/
virtual bool Create(const wxString& path) { return false; }
virtual bool Exists(const wxString& path) { return false; }
virtual bool Rename(const wxString& from, const wxString& to) { return false; }
virtual bool Remove(const wxString& path) { return false; }
wxString GetPath() const;
vfsOpenMode GetOpenMode() const;
};

12
rpcs3/Emu/FS/vfsLocalDir.cpp
View File

@ -2,9 +2,7 @@
#include "vfsLocalDir.h"
#include <direct.h>
vfsLocalDir::vfsLocalDir(const wxString& path)
: vfsDirBase(path)
, m_pos(0)
vfsLocalDir::vfsLocalDir(vfsDevice* device) : vfsDirBase(device)
{
}
@ -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);

3
rpcs3/Emu/FS/vfsLocalDir.h
View File

@ -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;

27
rpcs3/Emu/FS/vfsLocalFile.cpp
View File

@ -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)) &&
vfsFileBase::Open(vfsDevice::GetPs3Path(GetPs3Path(), path), mode);
return m_file.Open(vfsDevice::GetWinPath(m_device->GetLocalPath(), path), vfs2wx_mode(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)

4
rpcs3/Emu/FS/vfsLocalFile.h
View File

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

110
rpcs3/Emu/GS/GL/GLGSRender.cpp
View File

@ -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;
}

123
rpcs3/Emu/GS/GL/GLGSRender.h
View File

@ -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 5: return GL_CLAMP_TO_EDGE;//GL_CLAMP;
//case 6: return GL_MIRROR_CLAMP_TO_EDGE_EXT;
case 4: return GL_CLAMP_TO_BORDER;
case 5: return GL_CLAMP_TO_EDGE;
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_GENERATE_MIPMAP, tex.m_mipmap > 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, tex.Getmipmap() - 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_r = (tex.m_remap >> 2) & 0x3;
u8 remap_g = (tex.m_remap >> 4) & 0x3;
u8 remap_b = (tex.m_remap >> 6) & 0x3;
u8 remap_a = tex.GetRemap() & 0x3;
u8 remap_r = (tex.GetRemap() >> 2) & 0x3;
u8 remap_g = (tex.GetRemap() >> 4) & 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_T, GetGlWrap(tex.m_wrapt));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GetGlWrap(tex.m_wrapr));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, gl_tex_zfunc[tex.m_zfunc]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GetGlWrap(tex.GetWrapS()));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GetGlWrap(tex.GetWrapT()));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GetGlWrap(tex.GetWrapR()));
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);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, tex.m_minlod);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, tex.m_maxlod);
glTexEnvi(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, tex.GetBias());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, (tex.GetMinLOD() >> 8));
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_MAG_FILTER, gl_tex_filter[tex.m_mag_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.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* alpha = new u8[tex.m_width * tex.m_height];
u8* data = new u8[tex.GetWidth() * tex.GetHeight() * 3];
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);

3
rpcs3/Emu/GS/GL/GLVertexProgram.cpp
View File

@ -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";

202
rpcs3/Emu/GS/RSXTexture.cpp Normal file
View File

@ -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;
}

117
rpcs3/Emu/GS/RSXThread.cpp
View File

@ -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);

191
rpcs3/Emu/GS/RSXThread.h
View File

@ -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()
: m_width(0), m_height(0)
, m_offset(0)
, m_enabled(false)
RSXTexture();
RSXTexture(u8 index);
void Init();
, m_cubemap(false)
, m_dimension(0)
, m_format(0)
, m_mipmap(0)
, m_minlod(0)
, m_maxlod(1000)
, m_maxaniso(0)
{
}
// Offset
u32 GetOffset() const;
void SetRect(const u32 width, const u32 height)
{
m_width = width;
m_height = height;
}
// Format
u8 GetLocation() const;
bool isCubemap() const;
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)
{
m_cubemap = cubemap;
m_dimension = dimension;
m_format = format;
m_mipmap = mipmap;
}
// Address
u8 GetWrapS() const;
u8 GetWrapT() const;
u8 GetWrapR() const;
u8 GetUnsignedRemap() const;
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)
{
m_wraps = wraps;
m_wrapt = wrapt;
m_wrapr = wrapr;
m_unsigned_remap = unsigned_remap;
m_zfunc = zfunc;
m_gamma = gamma;
m_aniso_bias = aniso_bias;
m_signed_remap = signed_remap;
}
// Control0
bool IsEnabled() const;
u16 GetMinLOD() const;
u16 GetMaxLOD() const;
u8 GetMaxAniso() const;
bool IsAlphaKillEnabled() const;
void SetControl0(const bool enable, const u16 minlod, const u16 maxlod, const u8 maxaniso)
{
m_enabled = enable;
m_minlod = minlod;
m_maxlod = maxlod;
m_maxaniso = maxaniso;
}
// Control1
u32 GetRemap() const;
void SetControl1(u32 remap)
{
m_remap = remap;
}
// Filter
u16 GetBias() const;
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)
{
m_depth = depth;
m_pitch = pitch;
}
// Image Rect
u16 GetWidth() const;
u16 GetHeight() const;
void SetFilter(u16 bias, u8 min, u8 mag, u8 conv, u8 a_signed, u8 r_signed, u8 g_signed, u8 b_signed)
{
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;
}
void SetControl3(u16 depth, u32 pitch);
};
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)

13
rpcs3/Emu/HDD/HDD.cpp
View File

@ -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;
}

28
rpcs3/Emu/HDD/HDD.h
View File

@ -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)
: m_hdd_file(hdd_path, vfsReadWrite)
vfsHDD(vfsDevice* device, const wxString& hdd_path)
: 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();
}
};
};

7
rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
View File

@ -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;
}
}

6
rpcs3/Emu/SysCalls/Modules/cellFont.cpp
View File

@ -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;

4
rpcs3/Emu/SysCalls/Modules/cellGame.cpp
View File

@ -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;
}

6
rpcs3/Emu/SysCalls/Modules/cellResc.cpp
View File

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

85
rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
View File

@ -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);
}

12
rpcs3/Emu/SysCalls/Modules/sceNp.cpp Normal file
View File

@ -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()
{
}

26
rpcs3/Emu/SysCalls/Modules/sceNp.h Normal file
View File

@ -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];
};

281
rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp Normal file
View File

@ -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);
}

4
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View File

@ -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);
}

13
rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
View File

@ -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);
vfsStream* unpacked_stream = Emu.GetVFS().Open(unpacked_file, vfsWrite);
std::shared_ptr<vfsFileBase> packed_stream(Emu.GetVFS().OpenFile(packed_file, vfsRead));
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(stream, flags);
fd = sys_fs.GetNewId(Emu.GetVFS().OpenFile(unpacked_path, vfsRead), 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;
}

11
rpcs3/Emu/SysCalls/SysCalls.h
View File

@ -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,
u32 data, u32 data_size, int prio, u64 flags );
extern void sys_game_process_exitspawn(u32 path_addr, u32 argv_addr, u32 envp_addr,
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_write(s32 ch, u64 buf_addr, u32 len, u64 pwritelen_addr);
extern int sys_tty_read(u32 ch, u64 buf_addr, u32 len, u64 preadlen_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);

35
rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp
View File

@ -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;
Emu.GetVFS().GetDevice(path, localPath);
vfsLocalDir* dir = new vfsLocalDir(localPath);
if(!dir->Open(localPath))
vfsDirBase* dir = Emu.GetVFS().OpenDir(path);
if(!dir || !dir->IsOpened())
{
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;
}

105
rpcs3/Emu/SysCalls/lv2/SC_Process.cpp
View File

@ -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,
u32 data, u32 data_size, int prio, u64 flags )
void sys_game_process_exitspawn(
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.Log("path: %s", Memory.ReadString(path_addr).wx_str());
sc_p.Log("argv: 0x%x", Memory.Read32(argv_addr));
sc_p.Log("envp: 0x%x", Memory.Read32(envp_addr));
sc_p.Log("data: 0x%x", data);
sc_p.Log("data_size: 0x%x", data_size);
sc_p.Log("prio: %d", prio);
sc_p.Log("flags: %d", flags);
return CELL_OK;
sc_p.Error("sys_game_process_exitspawn 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;
}
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)",

7
rpcs3/Emu/SysCalls/lv2/SC_TTY.cpp
View File

@ -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));

6
rpcs3/Emu/System.cpp
View File

@ -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())
{

10
rpcs3/Emu/System.h
View File

@ -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; }

2
rpcs3/Gui/CompilerELF.cpp
View File

@ -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)

4
rpcs3/Gui/DisAsmFrame.cpp
View File

@ -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);

6
rpcs3/Gui/GameViewer.cpp
View File

@ -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(path);
vfsLocalFile f(nullptr);
if(!f.Open(path))
continue;
PSFLoader psf(f);
if(!psf.Load(false)) continue;
psf.m_info.root = m_games[i];

66
rpcs3/Gui/RSXDebugger.cpp
View File

@ -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,
render.m_textures[m_cur_texture].m_width,
render.m_textures[m_cur_texture].m_height, false);
GetAddress(render.m_textures[m_cur_texture].GetOffset(), location), 1,
render.m_textures[m_cur_texture].GetWidth(),
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 height = render.m_textures[m_cur_texture].m_height;
u32 width = render.m_textures[m_cur_texture].GetWidth();
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));
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->SetItem(i, 3, wxString::Format("%dD", render.m_textures[i].m_dimension));
m_list_texture->SetItem(i, 4, render.m_textures[i].m_enabled ? "True" : "False");
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, 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].m_width,
render.m_textures[i].m_height));
if(render.m_textures[i].IsEnabled())
{
m_list_texture->InsertItem(i, wxString::Format("%d", i));
u8 location = render.m_textures[i].GetLocation();
if(location > 1)
{
m_list_texture->SetItem(i, 1,
wxString::Format("Bad address (offset=0x%x, location=%d)", render.m_textures[i].GetOffset(), location));
}
else
{
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"));
}
}
}

2
rpcs3/Gui/VHDDManager.cpp
View File

@ -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));

8
rpcs3/Loader/Loader.cpp
View File

@ -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;
}

61
rpcs3/Loader/TRP.cpp Normal file
View File

@ -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;
}

36
rpcs3/Loader/TRP.h Normal file
View File

@ -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();
};

5
rpcs3/rpcs3.vcxproj
View File

@ -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>

15
rpcs3/rpcs3.vcxproj.filters
View File

@ -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" />

3
rpcs3/stdafx.h
View File

@ -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"