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

Merge branch 'master' of https://github.com/DHrpcs3/rpcs3

Browse Source
This commit is contained in:
Oil 2014-05-25 01:46:25 +04:00
commit 8a1227eaa2
24 changed files with 457 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -45,6 +45,10 @@
/bin/*.exp
rpcs3/git-version.h
# Visual Studio Profiler Files
*.vspx
*.psess
# Copyrighted files
/bin/data/
/bin/dev_flash/data/font

3
rpcs3.sln
View File

@ -460,4 +460,7 @@ Global
{74827EBD-93DC-5110-BA95-3F2AB029B6B0} = {5812E712-6213-4372-B095-9EB9BAA1F2DF}
{AC40FF01-426E-4838-A317-66354CEFAE88} = {E2A982F2-4B1A-48B1-8D77-A17A589C58D7}
EndGlobalSection
GlobalSection(Performance) = preSolution
HasPerformanceSessions = true
EndGlobalSection
EndGlobal

4
rpcs3/Emu/Cell/PPUDisAsm.h
View File

@ -1788,9 +1788,9 @@ private:
{
DisAsm_R2("icbi", ra, rb);
}
void DCBZ(u32 ra, u32 rs)
void DCBZ(u32 ra, u32 rb)
{
DisAsm_R2("dcbz", ra, rs);
DisAsm_R2("dcbz", ra, rb);
}
void LWZ(u32 rd, u32 ra, s32 d)
{

21
rpcs3/Emu/Cell/PPUInterpreter.h
View File

@ -2084,9 +2084,10 @@ private:
{
if (CheckCondition(bo, bi))
{
const u64 nextLR = CPU.PC + 4;
CPU.SetBranch(branchTarget((aa ? 0 : CPU.PC), bd), lk);
if(lk) CPU.LR = nextLR;
}
if(lk) CPU.LR = CPU.PC + 4;
}
void SC(u32 sc_code)
{
@ -2108,8 +2109,9 @@ private:
}
void B(s32 ll, u32 aa, u32 lk)
{
const u64 nextLR = CPU.PC + 4;
CPU.SetBranch(branchTarget(aa ? 0 : CPU.PC, ll), lk);
if(lk) CPU.LR = CPU.PC + 4;
if(lk) CPU.LR = nextLR;
}
void MCRF(u32 crfd, u32 crfs)
{
@ -2119,9 +2121,10 @@ private:
{
if (CheckCondition(bo, bi))
{
const u64 nextLR = CPU.PC + 4;
CPU.SetBranch(branchTarget(0, CPU.LR), true);
if(lk) CPU.LR = nextLR;
}
if(lk) CPU.LR = CPU.PC + 4;
}
void CRNOR(u32 crbd, u32 crba, u32 crbb)
{
@ -2171,9 +2174,10 @@ private:
{
if(bo & 0x10 || CPU.IsCR(bi) == (bo & 0x8))
{
const u64 nextLR = CPU.PC + 4;
CPU.SetBranch(branchTarget(0, CPU.CTR), true);
if(lk) CPU.LR = nextLR;
}
if(lk) CPU.LR = CPU.PC + 4;
}
void RLWIMI(u32 ra, u32 rs, u32 sh, u32 mb, u32 me, bool rc)
{
@ -2816,7 +2820,6 @@ private:
const u64 RA = CPU.GPR[ra];
const u64 RB = CPU.GPR[rb];
CPU.GPR[rd] = RA + RB;
CPU.XER.CA = CPU.IsCarry(RA, RB);
if(oe) UNK("addo");
if(rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]);
}
@ -3288,16 +3291,18 @@ private:
void EXTSW(u32 ra, u32 rs, bool rc)
{
CPU.GPR[ra] = (s64)(s32)CPU.GPR[rs];
//CPU.XER.CA = ((s64)CPU.GPR[ra] < 0); // ???
if(rc) CPU.UpdateCR0<s32>(CPU.GPR[ra]);
}
void ICBI(u32 ra, u32 rs)
{
// Clear jit for the specified block? Nothing to do in the interpreter.
}
void DCBZ(u32 ra, u32 rs)
void DCBZ(u32 ra, u32 rb)
{
//UNK("dcbz", false);
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
u8 *const cache_line = Memory.GetMemFromAddr(addr & ~127);
if (cache_line)
memset(cache_line, 0, 128);
_mm_mfence();
}
void LWZ(u32 rd, u32 ra, s32 d)

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

@ -581,7 +581,7 @@ void GLGSRender::WriteColourBufferD()
checkForGlError("glReadPixels(GL_RGBA, GL_UNSIGNED_INT_8_8_8_8)");
}
void GLGSRender::WriteBuffers()
void GLGSRender::WriteColorBuffers()
{
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_ALIGNMENT, 4);
@ -641,7 +641,6 @@ void GLGSRender::OnInitThread()
InitProcTable();
glEnable(GL_TEXTURE_2D);
glEnable(GL_SCISSOR_TEST);
#ifdef _WIN32
glSwapInterval(Ini.GSVSyncEnable.GetValue() ? 1 : 0);
@ -773,8 +772,10 @@ void GLGSRender::ExecCMD()
}
m_fbo.Bind();
if(Ini.GSDumpDepthBuffer.GetValue())
WriteDepthBuffer();
static const GLenum draw_buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
switch(m_surface_colour_target)
@ -813,20 +814,12 @@ void GLGSRender::ExecCMD()
checkForGlError("glColorMask");
}
//glFrontFace(m_front_face);
if(m_set_viewport_horizontal && m_set_viewport_vertical)
{
//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, m_scissor_y, m_scissor_w, m_scissor_h);
checkForGlError("glScissor");
}
if(m_clear_surface_mask)
{
GLbitfield f = 0;
@ -859,18 +852,6 @@ void GLGSRender::ExecCMD()
glClear(f);
}
if(m_set_front_polygon_mode)
{
glPolygonMode(GL_FRONT, m_front_polygon_mode);
checkForGlError("glPolygonMode(Front)");
}
if (m_set_back_polygon_mode)
{
glPolygonMode(GL_BACK, m_back_polygon_mode);
checkForGlError("glPolygonMode(Back)");
}
Enable(m_depth_test_enable, GL_DEPTH_TEST);
Enable(m_set_alpha_test, GL_ALPHA_TEST);
Enable(m_set_depth_bounds_test, GL_DEPTH_BOUNDS_TEST_EXT);
@ -879,12 +860,13 @@ void GLGSRender::ExecCMD()
Enable(m_set_cull_face_enable, GL_CULL_FACE);
Enable(m_set_dither, GL_DITHER);
Enable(m_set_stencil_test, GL_STENCIL_TEST);
Enable(m_set_scissor_horizontal && m_set_scissor_vertical, GL_SCISSOR_TEST);
Enable(m_set_line_smooth, GL_LINE_SMOOTH);
Enable(m_set_poly_smooth, GL_POLYGON_SMOOTH);
Enable(m_set_poly_offset_fill, GL_POLYGON_OFFSET_FILL);
Enable(m_set_poly_offset_line, GL_POLYGON_OFFSET_LINE);
Enable(m_set_poly_offset_point, GL_POLYGON_OFFSET_POINT);
//Enable(m_set_restart_index, GL_PRIMITIVE_RESTART); //Requires OpenGL 3.1+
//Enable(m_set_restart_index, GL_PRIMITIVE_RESTART); // Requires OpenGL 3.1+
if(m_set_clip_plane)
{
@ -900,6 +882,37 @@ void GLGSRender::ExecCMD()
checkForGlError("glEnable");
if (m_set_front_polygon_mode)
{
glPolygonMode(GL_FRONT, m_front_polygon_mode);
checkForGlError("glPolygonMode(Front)");
}
if (m_set_back_polygon_mode)
{
glPolygonMode(GL_BACK, m_back_polygon_mode);
checkForGlError("glPolygonMode(Back)");
}
if (m_set_poly_offset_scale_factor && m_set_poly_offset_bias)
{
glPolygonOffset(m_set_poly_offset_scale_factor, m_set_poly_offset_bias);
checkForGlError("glPolygonOffset");
}
if (m_set_logic_op)
{
glLogicOp(m_logic_op);
checkForGlError("glLogicOp");
}
if (m_set_scissor_horizontal && m_set_scissor_vertical)
{
glScissor(m_scissor_x, m_scissor_y, m_scissor_w, m_scissor_h);
checkForGlError("glScissor");
}
if(m_set_two_sided_stencil_test_enable)
{
if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass)
@ -1022,6 +1035,16 @@ void GLGSRender::ExecCMD()
checkForGlError("glCullFace");
}
if (m_set_front_face)
{
// Sanity check . Disgaea 3 return 0x1d0 here and cause openGL 0x0500
if (m_front_face == GL_CW || m_front_face == GL_CCW)
{
glFrontFace(m_front_face);
checkForGlError("glFrontFace");
}
}
if(m_set_alpha_func && m_set_alpha_ref)
{
glAlphaFunc(m_alpha_func, m_alpha_ref/255.0f);
@ -1045,7 +1068,7 @@ void GLGSRender::ExecCMD()
if(m_set_restart_index)
{
ConLog.Warning("m_set_restart_index requires glPrimitiveRestartIndex()");
//glPrimitiveRestartIndex(m_restart_index); //Requires OpenGL 3.1+
//glPrimitiveRestartIndex(m_restart_index); // Requires OpenGL 3.1+
//checkForGlError("glPrimitiveRestartIndex");
}
@ -1110,12 +1133,34 @@ void GLGSRender::ExecCMD()
DisableVertexData();
}
if(Ini.GSDumpColorBuffers.GetValue())
WriteBuffers();
if (Ini.GSDumpColorBuffers.GetValue())
WriteColorBuffers();
}
void GLGSRender::Flip()
{
// Fast path for non-MRT using glBlitFramebuffer
// TODO: check for MRT samples
if (m_fbo.IsCreated() && (m_surface_colour_target == CELL_GCM_SURFACE_TARGET_0 || m_surface_colour_target == CELL_GCM_SURFACE_TARGET_1))
{
GLfbo::Bind(GL_DRAW_FRAMEBUFFER, 0);
// Renderbuffer is upside turn , swapped srcY0 and srcY1
GLfbo::Blit(0, RSXThread::m_height, RSXThread::m_width, 0, 0, 0, RSXThread::m_width, RSXThread::m_height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
m_fbo.Bind();
for (uint i = 0; i<m_post_draw_objs.size(); ++i)
{
m_post_draw_objs[i].Draw();
}
m_frame->Flip(m_context);
m_fbo.Bind();
return;
}
if(m_set_scissor_horizontal && m_set_scissor_vertical)
{
glScissor(0, 0, RSXThread::m_width, RSXThread::m_height);
@ -1205,24 +1250,6 @@ void GLGSRender::Flip()
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);*/
if(m_fbo.IsCreated())
m_fbo.Bind();
for(uint i=0; i<m_post_draw_objs.size(); ++i)
{
m_post_draw_objs[i].Draw();
}
m_frame->Flip(m_context);
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);

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

@ -827,11 +827,11 @@ private:
virtual void Close();
bool LoadProgram();
void WriteDepthBuffer();
void WriteColorBuffers();
void WriteColourBufferA();
void WriteColourBufferB();
void WriteColourBufferC();
void WriteColourBufferD();
void WriteBuffers();
void DrawObjects();

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

@ -11,7 +11,10 @@ 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);
case CELL_GCM_LOCATION_MAIN:
u64 realAddr;
Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + offset, realAddr); // TODO: Error Check?
return realAddr;
}
ConLog.Error("GetAddress(offset=0x%x, location=0x%x)", location);
@ -762,6 +765,10 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, mem32_ptr_t& args, const u3
m_set_logic_op = ARGS(0) ? true : false;
break;
case NV4097_SET_LOGIC_OP:
m_logic_op = ARGS(0);
break;
case NV4097_SET_CULL_FACE_ENABLE:
m_set_cull_face_enable = ARGS(0) ? true : false;
break;

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

@ -166,7 +166,6 @@ public:
bool m_set_blend;
bool m_set_depth_bounds_test;
bool m_depth_test_enable;
bool m_set_logic_op;
bool m_set_cull_face_enable;
bool m_set_dither;
bool m_set_stencil_test;
@ -176,6 +175,11 @@ public:
bool m_set_poly_offset_line;
bool m_set_poly_offset_point;
bool m_set_poly_offset_scale_factor;
u32 m_poly_offset_scale_factor;
bool m_set_poly_offset_bias;
u32 m_poly_offset_bias;
bool m_set_restart_index;
u32 m_restart_index;
@ -198,6 +202,9 @@ public:
bool m_set_back_polygon_mode;
u32 m_back_polygon_mode;
bool m_set_logic_op;
u32 m_logic_op;
u32 m_clear_surface_mask;
u32 m_clear_surface_z;
u8 m_clear_surface_s;
@ -382,6 +389,7 @@ public:
u32 m_surface_colour_target;
bool m_set_front_face;
u32 m_front_face;
u8 m_begin_end;
@ -426,6 +434,9 @@ protected:
m_clear_z = 0xffffff;
m_clear_s = 0;
m_poly_offset_scale_factor = 0;
m_poly_offset_bias = 0;
m_depth_bounds_min = 0.0;
m_depth_bounds_max = 1.0;
m_restart_index = 0xffffffff;
@ -498,6 +509,8 @@ protected:
m_set_poly_offset_fill = false;
m_set_poly_offset_line = false;
m_set_poly_offset_point = false;
m_set_poly_offset_scale_factor = false;
m_set_poly_offset_bias = false;
m_set_restart_index = false;
m_clear_surface_mask = 0;

7
rpcs3/Emu/GS/sysutil_video.h
View File

@ -232,6 +232,7 @@ static const CellVideoOutResolution ResolutionTable[] =
{1440, 1080}, //11 - 6
{1280, 1080}, //12 - 7
{960, 1080}, //13 - 8
{960, 540}, //14 - 9
};
inline static u32 ResolutionIdToNum(u32 id)
@ -252,9 +253,10 @@ inline static u32 ResolutionIdToNum(u32 id)
6, //11
7, //12
8, //13
9, //14
};
return id <= 13 ? res[id] : 0;
return id <= 14 ? res[id] : 0;
}
inline static u32 ResolutionNumToId(u32 num)
@ -270,7 +272,8 @@ inline static u32 ResolutionNumToId(u32 num)
11,
12,
13,
14,
};
return num <= 8 ? res[num] : 0;
return num <= 9 ? res[num] : 0;
}

9
rpcs3/Emu/Io/Pad.cpp
View File

@ -2,6 +2,9 @@
#include "Pad.h"
#include "Null/NullPadHandler.h"
#include "Windows/WindowsPadHandler.h"
#if defined(_WIN32)
#include "XInput/XInputPadHandler.h"
#endif
PadManager::PadManager()
: m_pad_handler(nullptr)
@ -25,6 +28,12 @@ void PadManager::Init(const u32 max_connect)
m_pad_handler.reset(new WindowsPadHandler());
break;
#if defined(_WIN32)
case 2:
m_pad_handler.reset(new XInputPadHandler());
break;
#endif
default:
case 0:
m_pad_handler.reset(new NullPadHandler());

2
rpcs3/Emu/Io/PadHandler.h
View File

@ -220,7 +220,7 @@ public:
virtual ~PadHandlerBase() = default;
//Set value to set pressure/axi to certain level, otherwise 0/255 default
void Key(const u32 code, bool pressed, u16 value=256)
void Key(const u32 code, bool pressed, u16 value=255)
{
for(Pad& pad : m_pads)
{

181
rpcs3/Emu/Io/XInput/XInputPadHandler.cpp Normal file
View File

@ -0,0 +1,181 @@
#include "stdafx.h"
#if defined (_WIN32)
#include "XInputPadHandler.h"
#include <cstring>
namespace {
const DWORD THREAD_TIMEOUT = 1000;
const DWORD THREAD_SLEEP = 10;
const DWORD THREAD_SLEEP_INACTIVE = 100;
const DWORD MAX_GAMEPADS = 4;
const DWORD XINPUT_GAMEPAD_GUIDE = 0x0400;
const DWORD XINPUT_GAMEPAD_BUTTONS = 16;
const LPCWSTR LIBRARY_FILENAMES[] = {
L"xinput1_4.dll",
L"xinput1_3.dll",
L"xinput1_2.dll",
L"xinput9_1_0.dll"
};
inline u16 ConvertAxis(SHORT value)
{
return static_cast<u16>((value + 32768l) >> 8);
}
}
XInputPadHandler::XInputPadHandler() : active(false), thread(nullptr), library(nullptr), xinputGetState(nullptr), xinputEnable(nullptr)
{
}
XInputPadHandler::~XInputPadHandler()
{
Close();
}
void XInputPadHandler::Init(const u32 max_connect)
{
for (auto it : LIBRARY_FILENAMES)
{
library = LoadLibrary(it);
if (library)
{
xinputEnable = reinterpret_cast<PFN_XINPUTENABLE>(GetProcAddress(library, "XInputEnable"));
xinputGetState = reinterpret_cast<PFN_XINPUTGETSTATE>(GetProcAddress(library, reinterpret_cast<LPCSTR>(100)));
if (!xinputGetState)
{
xinputGetState = reinterpret_cast<PFN_XINPUTGETSTATE>(GetProcAddress(library, "XInputGetState"));
}
if (xinputEnable && xinputGetState)
{
break;
}
FreeLibrary(library);
library = nullptr;
xinputEnable = nullptr;
xinputGetState = nullptr;
}
}
if (library)
{
std::memset(&m_info, 0, sizeof m_info);
m_info.max_connect = max_connect;
for (u32 i = 0, max = std::min(max_connect, u32(MAX_GAMEPADS)); i != max; ++i)
{
m_pads.emplace_back(
CELL_PAD_STATUS_ASSIGN_CHANGES,
CELL_PAD_SETTING_PRESS_OFF | CELL_PAD_SETTING_SENSOR_OFF,
CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE,
CELL_PAD_DEV_TYPE_STANDARD
);
auto & pad = m_pads.back();
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_DPAD_UP, CELL_PAD_CTRL_UP);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_DPAD_DOWN, CELL_PAD_CTRL_DOWN);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_DPAD_LEFT, CELL_PAD_CTRL_LEFT);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_DPAD_RIGHT, CELL_PAD_CTRL_RIGHT);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_START, CELL_PAD_CTRL_START);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_BACK, CELL_PAD_CTRL_SELECT);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_LEFT_THUMB, CELL_PAD_CTRL_L3);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_RIGHT_THUMB, CELL_PAD_CTRL_R3);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_LEFT_SHOULDER, CELL_PAD_CTRL_L1);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_RIGHT_SHOULDER, CELL_PAD_CTRL_R1);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_GUIDE, 0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x0); // Reserved
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_A, CELL_PAD_CTRL_CROSS);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_B, CELL_PAD_CTRL_CIRCLE);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_X, CELL_PAD_CTRL_SQUARE);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_Y, CELL_PAD_CTRL_TRIANGLE);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_L2);
pad.m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_R2);
pad.m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X, 0, 0);
pad.m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y, 0, 0);
pad.m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, 0, 0);
pad.m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, 0, 0);
}
active = true;
thread = CreateThread(NULL, 0, &XInputPadHandler::ThreadProcProxy, this, 0, NULL);
}
}
void XInputPadHandler::Close()
{
if (library)
{
if (thread)
{
active = false;
if (WaitForSingleObject(thread, THREAD_TIMEOUT) != WAIT_OBJECT_0)
ConLog.Error("XInput thread could not stop within %d milliseconds", THREAD_TIMEOUT);
thread = nullptr;
}
FreeLibrary(library);
library = nullptr;
xinputGetState = nullptr;
xinputEnable = nullptr;
}
m_pads.clear();
}
DWORD XInputPadHandler::ThreadProcedure()
{
while (active)
{
XINPUT_STATE state;
DWORD result;
DWORD online = 0;
for (DWORD i = 0; i != m_pads.size(); ++i)
{
auto & pad = m_pads[i];
result = (* xinputGetState)(i, &state);
switch (result)
{
case ERROR_DEVICE_NOT_CONNECTED:
pad.m_port_status &= ~CELL_PAD_STATUS_CONNECTED;
break;
case ERROR_SUCCESS:
++online;
pad.m_port_status |= CELL_PAD_STATUS_CONNECTED;
for (DWORD j = 0; j != XINPUT_GAMEPAD_BUTTONS; ++j)
{
bool pressed = state.Gamepad.wButtons & (1 << j);
pad.m_buttons[j].m_pressed = pressed;
pad.m_buttons[j].m_value = pressed ? 255 : 0;
}
pad.m_buttons[XINPUT_GAMEPAD_BUTTONS].m_pressed = state.Gamepad.bLeftTrigger > 0;
pad.m_buttons[XINPUT_GAMEPAD_BUTTONS].m_value = state.Gamepad.bLeftTrigger;
pad.m_buttons[XINPUT_GAMEPAD_BUTTONS + 1].m_pressed = state.Gamepad.bRightTrigger > 0;
pad.m_buttons[XINPUT_GAMEPAD_BUTTONS + 1].m_value = state.Gamepad.bRightTrigger;
pad.m_sticks[0].m_value = ConvertAxis(state.Gamepad.sThumbLX);
pad.m_sticks[1].m_value = ConvertAxis(state.Gamepad.sThumbLY);
pad.m_sticks[2].m_value = ConvertAxis(state.Gamepad.sThumbRX);
pad.m_sticks[3].m_value = ConvertAxis(state.Gamepad.sThumbRY);
break;
}
}
Sleep((online > 0) ? THREAD_SLEEP : THREAD_SLEEP_INACTIVE);
m_info.now_connect = online;
}
return 0;
}
DWORD WINAPI XInputPadHandler::ThreadProcProxy(LPVOID parameter)
{
return reinterpret_cast<XInputPadHandler *>(parameter)->ThreadProcedure();
}
#endif

30
rpcs3/Emu/Io/XInput/XInputPadHandler.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
#include "Emu/Io/PadHandler.h"
#include <Xinput.h>
class XInputPadHandler : public PadHandlerBase
{
public:
XInputPadHandler();
~XInputPadHandler();
void Init(const u32 max_connect) override;
void Close() override;
private:
typedef void (WINAPI * PFN_XINPUTENABLE)(BOOL);
typedef DWORD (WINAPI * PFN_XINPUTGETSTATE)(DWORD, XINPUT_STATE *);
private:
DWORD ThreadProcedure();
static DWORD WINAPI ThreadProcProxy(LPVOID parameter);
private:
mutable bool active;
HANDLE thread;
HMODULE library;
PFN_XINPUTGETSTATE xinputGetState;
PFN_XINPUTENABLE xinputEnable;
};

65
rpcs3/Emu/Memory/Memory.cpp
View File

@ -614,21 +614,25 @@ u32 VirtualMemoryBlock::UnmapAddress(u64 addr)
bool VirtualMemoryBlock::Read8(const u64 addr, u8* value)
{
u64 realAddr;
*value = Memory.Read8(realAddr = getRealAddr(addr));
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
*value = Memory.Read8(realAddr);
return true;
}
bool VirtualMemoryBlock::Read16(const u64 addr, u16* value)
{
u64 realAddr;
*value = Memory.Read16(realAddr = getRealAddr(addr));
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
*value = Memory.Read16(realAddr);
return true;
}
bool VirtualMemoryBlock::Read32(const u64 addr, u32* value)
{
u64 realAddr = getRealAddr(addr);
if (realAddr == 0)
u64 realAddr;
if (!getRealAddr(addr, realAddr))
return false;
*value = Memory.Read32(realAddr);
return true;
@ -637,63 +641,78 @@ bool VirtualMemoryBlock::Read32(const u64 addr, u32* value)
bool VirtualMemoryBlock::Read64(const u64 addr, u64* value)
{
u64 realAddr;
*value = Memory.Read64(realAddr = getRealAddr(addr));
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
*value = Memory.Read64(realAddr);
return true;
}
bool VirtualMemoryBlock::Read128(const u64 addr, u128* value)
{
u64 realAddr;
*value = Memory.Read128(realAddr = getRealAddr(addr));
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
*value = Memory.Read128(realAddr);
return true;
}
bool VirtualMemoryBlock::Write8(const u64 addr, const u8 value)
{
u64 realAddr;
Memory.Write8(realAddr = getRealAddr(addr), value);
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
Memory.Write8(realAddr, value);
return true;
}
bool VirtualMemoryBlock::Write16(const u64 addr, const u16 value)
{
u64 realAddr;
Memory.Write16(realAddr = getRealAddr(addr), value);
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
Memory.Write16(realAddr, value);
return true;
}
bool VirtualMemoryBlock::Write32(const u64 addr, const u32 value)
{
u64 realAddr;
Memory.Write32(realAddr = getRealAddr(addr), value);
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
Memory.Write32(realAddr, value);
return true;
}
bool VirtualMemoryBlock::Write64(const u64 addr, const u64 value)
{
u64 realAddr;
Memory.Write64(realAddr = getRealAddr(addr), value);
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
Memory.Write64(realAddr, value);
return true;
}
bool VirtualMemoryBlock::Write128(const u64 addr, const u128 value)
{
u64 realAddr;
Memory.Write128(realAddr = getRealAddr(addr), value);
return realAddr != 0;
if(!getRealAddr(addr, realAddr))
return false;
Memory.Write128(realAddr, value);
return true;
}
u64 VirtualMemoryBlock::getRealAddr(u64 addr)
bool VirtualMemoryBlock::getRealAddr(u64 addr, u64& result)
{
for(u32 i=0; i<m_mapped_memory.size(); ++i)
{
if(addr >= m_mapped_memory[i].addr && addr < m_mapped_memory[i].addr + m_mapped_memory[i].size)
{
return m_mapped_memory[i].realAddress + (addr - m_mapped_memory[i].addr);
result = m_mapped_memory[i].realAddress + (addr - m_mapped_memory[i].addr);
return true;
}
}
return 0;
return false;
}
u64 VirtualMemoryBlock::getMappedAddress(u64 realAddress)

10
rpcs3/Emu/Memory/Memory.h
View File

@ -333,11 +333,11 @@ public:
return true;
}
bool CopyFromReal(u32 to, void* real, u32 count) // (4K pages) copy from real to virtual memory
bool CopyFromReal(u32 to, const void* real, u32 count) // (4K pages) copy from real to virtual memory
{
if (!count) return true;
u8* from = (u8*)real;
const u8* from = (const u8*)real;
if (u32 frag = to & 4095)
{
@ -795,6 +795,12 @@ public:
return this->m_addr;
}
u32 AppendRawBytes(const u8 * bytes, size_t count) {
Memory.CopyFromReal(this->m_addr, bytes, count);
this->m_addr += count;
return this->m_addr;
}
u32 Skip(const u32 offset) { return this->m_addr += offset; }
operator be_t<T>*() { return GetPtr(); }

5
rpcs3/Emu/Memory/MemoryBlock.h
View File

@ -281,8 +281,9 @@ public:
virtual bool Write64(const u64 addr, const u64 value);
virtual bool Write128(const u64 addr, const u128 value);
// return the real address given a mapped address, if not mapped return 0
u64 getRealAddr(u64 addr);
// try to get the real address given a mapped address
// return true for success
bool getRealAddr(u64 addr, u64& result);
// return the mapped address given a real address, if not mapped return 0
u64 getMappedAddress(u64 realAddress);

18
rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
View File

@ -339,16 +339,16 @@ int cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
{
ConLog.Warning("bad flip!");
//cellGcmCallback(ctxt.GetAddr(), current + 8 - end);
//copied:
//copied:
CellGcmControl& ctrl = (CellGcmControl&)Memory[gcm_info.control_addr];
CellGcmControl& ctrl = (CellGcmControl&)Memory[gcm_info.control_addr];
const s32 res = ctxt->current - ctxt->begin - ctrl.put;
const s32 res = ctxt->current - ctxt->begin - ctrl.put;
if(res > 0) Memory.Copy(ctxt->begin, ctxt->current - res, res);
ctxt->current = ctxt->begin + res;
ctrl.put = res;
ctrl.get = 0;
if(res > 0) Memory.Copy(ctxt->begin, ctxt->current - res, res);
ctxt->current = ctxt->begin + res;
ctrl.put = res;
ctrl.get = 0;
}
current = ctxt->current;
@ -575,9 +575,7 @@ int32_t cellGcmIoOffsetToAddress(u32 ioOffset, u64 address)
{
u64 realAddr;
realAddr = Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + ioOffset);
if (!realAddr)
if (!Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + ioOffset, realAddr))
return CELL_GCM_ERROR_FAILURE;
Memory.Write64(address, realAddr);

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

@ -169,6 +169,10 @@ int cellPamfVerify(mem_ptr_t<PamfHeader> pAddr, u64 fileSize)
int cellPamfReaderInitialize(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<PamfHeader> pAddr, u64 fileSize, u32 attribute)
{
// Skip PAMF initialization
if (Ini.SkipPamf.GetValue())
return -1;
cellPamf.Warning("cellPamfReaderInitialize(pSelf=0x%x, pAddr=0x%x, fileSize=%d, attribute=0x%x)",
pSelf.GetAddr(), pAddr.GetAddr(), fileSize, attribute);

18
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View File

@ -201,7 +201,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
case CELL_PNGDEC_ARGB:
{
const char nComponents = 4;
const int nComponents = 4;
image_size *= nComponents;
if (bytesPerLine > width * nComponents || flip) //check if we need padding
{
@ -225,13 +225,19 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
}
else
{
for (uint i = 0; i < image_size; i += nComponents)
uint* dest = (uint*)new char[image_size];
uint* source_current = (uint*)&(image.get()[0]);
uint* dest_current = dest;
for (uint i = 0; i < image_size / nComponents; i++)
{
data += image.get()[i + 3];
data += image.get()[i + 0];
data += image.get()[i + 1];
data += image.get()[i + 2];
uint val = *source_current;
*dest_current = (val >> 24) | (val << 8); // set alpha (A8) as leftmost byte
source_current++;
dest_current++;
}
// NOTE: AppendRawBytes has diff side-effect vs Memory.CopyFromReal
data.AppendRawBytes((u8*)dest, image_size);
delete[] dest;
}
}
break;

7
rpcs3/Gui/MainFrame.cpp
View File

@ -372,6 +372,7 @@ void MainFrame::Config(wxCommandEvent& WXUNUSED(event))
wxCheckBox* chbox_gs_log_prog = new wxCheckBox(p_graphics, wxID_ANY, "Log vertex/fragment programs");
wxCheckBox* chbox_gs_dump_depth = new wxCheckBox(p_graphics, wxID_ANY, "Write Depth Buffer");
wxCheckBox* chbox_gs_dump_color = new wxCheckBox(p_graphics, wxID_ANY, "Write Color Buffers");
wxCheckBox* chbox_skip_pamf = new wxCheckBox(p_graphics, wxID_ANY, "Skip Pamf");
wxCheckBox* chbox_gs_vsync = new wxCheckBox(p_graphics, wxID_ANY, "VSync");
wxCheckBox* chbox_audio_dump = new wxCheckBox(p_audio, wxID_ANY, "Dump to file");
wxCheckBox* chbox_hle_logging = new wxCheckBox(p_hle, wxID_ANY, "Log all SysCalls");
@ -400,6 +401,9 @@ void MainFrame::Config(wxCommandEvent& WXUNUSED(event))
cbox_pad_handler->Append("Null");
cbox_pad_handler->Append("Windows");
#if defined (_WIN32)
cbox_pad_handler->Append("XInput");
#endif
//cbox_pad_handler->Append("DirectInput");
cbox_keyboard_handler->Append("Null");
@ -444,6 +448,7 @@ void MainFrame::Config(wxCommandEvent& WXUNUSED(event))
chbox_gs_log_prog ->SetValue(Ini.GSLogPrograms.GetValue());
chbox_gs_dump_depth ->SetValue(Ini.GSDumpDepthBuffer.GetValue());
chbox_gs_dump_color ->SetValue(Ini.GSDumpColorBuffers.GetValue());
chbox_skip_pamf ->SetValue(Ini.SkipPamf.GetValue());
chbox_gs_vsync ->SetValue(Ini.GSVSyncEnable.GetValue());
chbox_audio_dump ->SetValue(Ini.AudioDumpToFile.GetValue());
chbox_hle_logging ->SetValue(Ini.HLELogging.GetValue());
@ -499,6 +504,7 @@ void MainFrame::Config(wxCommandEvent& WXUNUSED(event))
s_subpanel_graphics->Add(chbox_gs_log_prog, wxSizerFlags().Border(wxALL, 5).Expand());
s_subpanel_graphics->Add(chbox_gs_dump_depth, wxSizerFlags().Border(wxALL, 5).Expand());
s_subpanel_graphics->Add(chbox_gs_dump_color, wxSizerFlags().Border(wxALL, 5).Expand());
s_subpanel_graphics->Add(chbox_skip_pamf, wxSizerFlags().Border(wxALL, 5).Expand());
s_subpanel_graphics->Add(chbox_gs_vsync, wxSizerFlags().Border(wxALL, 5).Expand());
// Input - Output
@ -548,6 +554,7 @@ void MainFrame::Config(wxCommandEvent& WXUNUSED(event))
Ini.GSLogPrograms.SetValue(chbox_gs_log_prog->GetValue());
Ini.GSDumpDepthBuffer.SetValue(chbox_gs_dump_depth->GetValue());
Ini.GSDumpColorBuffers.SetValue(chbox_gs_dump_color->GetValue());
Ini.SkipPamf.SetValue(chbox_skip_pamf->GetValue());
Ini.PadHandlerMode.SetValue(cbox_pad_handler->GetSelection());
Ini.KeyboardHandlerMode.SetValue(cbox_keyboard_handler->GetSelection());
Ini.MouseHandlerMode.SetValue(cbox_mouse_handler->GetSelection());

24
rpcs3/Gui/RSXDebugger.cpp
View File

@ -322,20 +322,28 @@ void RSXDebugger::GoToGet(wxCommandEvent& event)
{
if (!RSXReady()) return;
CellGcmControl* ctrl = (CellGcmControl*)&Memory[Emu.GetGSManager().GetRender().m_ctrlAddress];
m_addr = Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + ctrl->get);
t_addr->SetValue(wxString::Format("%08x", m_addr));
UpdateInformation();
event.Skip();
u64 realAddr;
if (Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + ctrl->get, realAddr)) {
m_addr = realAddr; // WARNING: Potential Truncation? Cast from u64 to u32
t_addr->SetValue(wxString::Format("%08x", m_addr));
UpdateInformation();
event.Skip();
}
// TODO: We should probably throw something?
}
void RSXDebugger::GoToPut(wxCommandEvent& event)
{
if (!RSXReady()) return;
CellGcmControl* ctrl = (CellGcmControl*)&Memory[Emu.GetGSManager().GetRender().m_ctrlAddress];
m_addr = Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + ctrl->put);
t_addr->SetValue(wxString::Format("%08x", m_addr));
UpdateInformation();
event.Skip();
u64 realAddr;
if (Memory.RSXIOMem.getRealAddr(Memory.RSXIOMem.GetStartAddr() + ctrl->put, realAddr)) {
m_addr = realAddr; // WARNING: Potential Truncation? Cast from u64 to u32
t_addr->SetValue(wxString::Format("%08x", m_addr));
UpdateInformation();
event.Skip();
}
// TODO: We should probably throw something?
}
void RSXDebugger::UpdateInformation()

4
rpcs3/Ini.h
View File

@ -117,6 +117,7 @@ public:
IniEntry<bool> HLEExitOnStop;
IniEntry<u8> HLELogLvl;
IniEntry<u8> SysLanguage;
IniEntry<bool> SkipPamf;
IniEntry<int> PadHandlerLStickLeft;
IniEntry<int> PadHandlerLStickDown;
@ -161,6 +162,7 @@ public:
GSLogPrograms.Init("LogPrograms", path);
GSDumpColorBuffers.Init("DumpColorBuffers", path);
GSDumpDepthBuffer.Init("DumpDepthBuffer", path);
SkipPamf.Init("SkipPamf", path);
path = DefPath + "/" + "IO";
PadHandlerMode.Init("PadHandlerMode", path);
@ -221,6 +223,7 @@ public:
GSLogPrograms.Load(false);
GSDumpColorBuffers.Load(false);
GSDumpDepthBuffer.Load(false);
SkipPamf.Load(false);
PadHandlerMode.Load(1);
KeyboardHandlerMode.Load(0);
MouseHandlerMode.Load(0);
@ -271,6 +274,7 @@ public:
GSLogPrograms.Save();
GSDumpColorBuffers.Save();
GSDumpDepthBuffer.Save();
SkipPamf.Save();
PadHandlerMode.Save();
KeyboardHandlerMode.Save();
MouseHandlerMode.Save();

2
rpcs3/rpcs3.vcxproj
View File

@ -350,6 +350,7 @@
<ClCompile Include="Emu\Io\Keyboard.cpp" />
<ClCompile Include="Emu\Io\Mouse.cpp" />
<ClCompile Include="Emu\Io\Pad.cpp" />
<ClCompile Include="Emu\Io\XInput\XInputPadHandler.cpp" />
<ClCompile Include="Emu\Memory\Memory.cpp" />
<ClCompile Include="Emu\SysCalls\Callback.cpp" />
<ClCompile Include="Emu\SysCalls\FuncList.cpp" />
@ -544,6 +545,7 @@
<ClInclude Include="Emu\Io\Windows\WindowsKeyboardHandler.h" />
<ClInclude Include="Emu\Io\Windows\WindowsMouseHandler.h" />
<ClInclude Include="Emu\Io\Windows\WindowsPadHandler.h" />
<ClInclude Include="Emu\Io\XInput\XInputPadHandler.h" />
<ClInclude Include="Emu\Memory\Memory.h" />
<ClInclude Include="Emu\Memory\MemoryBlock.h" />
<ClInclude Include="Emu\SysCalls\Callback.h" />

9
rpcs3/rpcs3.vcxproj.filters
View File

@ -71,6 +71,9 @@
<Filter Include="Emu\Io\Windows">
<UniqueIdentifier>{899523fa-c26a-44ea-b272-73c4585e3821}</UniqueIdentifier>
</Filter>
<Filter Include="Emu\Io\XInput">
<UniqueIdentifier>{a77ab520-4399-4c95-a7ee-985c9a5ad694}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="rpcs3.cpp">
@ -505,6 +508,9 @@
<ClCompile Include="Crypto\lz.cpp">
<Filter>Crypto</Filter>
</ClCompile>
<ClCompile Include="Emu\Io\XInput\XInputPadHandler.cpp">
<Filter>Emu\Io\XInput</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="rpcs3.rc" />
@ -990,5 +996,8 @@
<ClInclude Include="Gui\AboutDialog.h">
<Filter>Gui</Filter>
</ClInclude>
<ClInclude Include="Emu\Io\XInput\XInputPadHandler.h">
<Filter>Emu\Io\XInput</Filter>
</ClInclude>
</ItemGroup>
</Project>