RPCS3 v0.0.4-6820

RPCS3 es un  emulador de código abierto de Sony PlayStation 3 y debugger programado en C++ para Windows y Linux.El emulador empezó a desarrollarse a principios de 2011 y utiliza como modos para renderizar los gráficos el DirectX 12, Vulkan y OpenGL. El emulador llega empezar y en algunos casos es capaz de correr bastantes juegos comerciales y PlayStation 3 SDK demos. Muchos más títulos se van añadiendo a la lista de compatibilidad y empezando a ser jugábles gracias a nuestros contribuidores. El código fuente de RPCS3 es público en nuestro GitHub. Puedes encontrar las últimas revisiones compiladas en  AppVeyor o compilarlas tu mismo.

Por ahora funcionan muchos juegos algunos incluso a una velocidad perfecta, otros se puedeen completar y en algunos la velocidad al menos del sonido es algo lenta, hay juegos que aún no hacen  nada pero parece que puede ir mejorando más rápido ya que ahora se puede dedicar al emulador a tiempo completo si queréis apoyarlo y ayudar en su desarrollo puedes hacerlo en su página de patreon:
https://www.patreon.com/Nekotekina

REQUISITOS MINIMOS:
- Windows 7 64-bit or greater / Linux 64-bit.
- A modern x64 processor with SSSE3 support.
- A GPU that supports OpenGL 4.3 or greater.
- Minimum: 4GB of RAM. Recommended: 8GB of RAM or greater.
- Microsoft Visual C++ 2015 redistributable.
- PlayStation 3 PS3UPDAT.PUP system software file.
- PlayStation 3 self-dumped games or applications.
- Storage requirements will expand depending on installed PlayStation 3 software.
- We do not support piracy. All system software should be self-dumped.

GUIA.
https://rpcs3.net/quickstart

CAMBIOS:

This changelog lists the main (but not all) changes made since 0.0.3

» Resolution Scaling (up to 10K)!
» Anisotropic Filtering (up to 16x)!
» Linux AppImages!
» Trophies!
» Save Data Manager!
» Basic Networking Support (YouTube now works)!
» Evdev Controller Support!
» Improved Linux and BSD Support!
» Low-Level Emulation of cellGcm: Even more games now working!
» Huge Compatibility and Performance Improvements!
» Huge GUI Improvements!
» And TONS of Bugfixes as always!

Core
– Fixes idm::init, fxm::init
– Re-enable thread_local for all platforms
– Fixes ipc_manager::add
– Fixes access violation handler
– Fixes decrypt_self usage
– Patch: new ‘load’ syntax: [load, path_name1] – load sequence, [load, path_name2, -0x40] – same, but modify the addresses by -64
– mutex.cpp: New concept update (incomplete)
– Escapes problematic characters in VFS
– Added support for passing commandline arguments to ELF executable

Memory
– Allow overlapping ranges in cellGcmMapEaIoAdress with coherency check
– Fix deadlock in vm::unmap
– sys_mmapper: minor range fix
– Improved lv2_memory object
– Fixed utils::memory_decommit
– vm.cpp cleanup

PPU
– Sets PPU Recompiler (LLVM) as default option instead of PPU Interpreter (Fast)
– Implemented PPU Page Faults
– Fixed a crash on Recompiler due to null jit
– Implemented CALL_FUNC
– Fixes for instruction editor
– Optimizes PPU module loading
– ppu_acontext draft (Work in Progress)

SPU
– Re-implements timing in the SPU concurrency watchdog code. It is now possible to set a hint number of threads with little performance loss, e.g it is now possible to set ‘preferred threads’ to something like 2 and set a penalty of 0 to significantly improve smoothness if running a low end CPU. Note that games which run better with low ‘preferred threads’ values still need a delay penalty greater than 0 (leave it at 3)
– Copies sys_spu_segment info in SPU Thread Group
– Implemented syscalls _sys_spu_image_import, sys_spu_elf_get_information, sys_spu_elf_get_segments, _sys_spu_image_get_information, _sys_spu_image_get_segments, sys_event_port_connect_ipc
– sys_spu_image: Cleanup and extends templates
– Fixed sys_raw_spu_load, sys_raw_spu_image_load
– RawSPU: Implemented Prxy_TagStatus_offs (rollback to immediate MFC transfers)
– RawSPU: Implemented read SPU_NPC_offs
– RawSPU: Implemented read SPU_RunCntl_offs
– Adds vm::page_protect to SPU segments
– Implemented FM instruction for Interpreter Fast and Recompiler ASMJIT
– Fixes a bug in FMA/FMS/FNMS where cmpunord was used as an optimization but inadvertently broke some corner cases
– Implemented readch(mfc_cmd)
– Save and restore mfc cmd: SPU accuracy change, docs state registers are in an ‘undefined state’ after writing to mfc_cmd, but in practice though, they are just left alone

HLE
– Fixed sys_get_random_number, sys_rwlock_runlock, sys_rwlock_wlock, sys_rwlock_wunlock, sys_semaphore_wait (on timeout), sys_event_queue_receive, cellOskDialogLoadAsync, _sys_strncasecmp, cellGameGetParam, cellGameSetParam
– Fixed syscalls _sys_lwcond_signal, _sys_lwcond_signal_all, sys_event_port_connect_ipc
– Rewritten sys_mempool to be thread safe
– Registered new functions on cellCrossController, cellOskDialog, cellSailRec, cellSysutil, sceNp, sceNp2, sceNpSns, sceNpTus, cellRec, cellGameExec, cellGameResc, cellSysutilAvc2, cellSysutilAvconfExt, cellSearchUtility, cellUsbd, sys_net, cellHttp, cellNetCtl, cellAtracMulti, cellAtrac, cell_FreeType2
– Fixed sys_timer initial set state to correctly be STOP instead of RUN
– cellGame: Minor refactoring
– cellRec: Minor fixes
– Registered _sys_rwlock_trywlock
– Re-implemented the ‘Hook static functions’ option
– Refactored sys_lwmutex, sys_lwcond
– Implemented cellSslCertificateLoader, cellHttpUtilParseUri, _sys_tolower, _sys_toupper, __sys_look_ctype_table
– Fixed backspace in onScreenKeyboard
– Rewritten cellVideoOutConfigure, _sys_memcmp, _sys_strlen, _sys_strcmp, _sys_strncmp, _sys_strcat, _sys_strcrp, _sys_strrch, _sys_strncpy, _sys_strncat
– Implemented fs::file::get_handle
– Implemented fs::error::notempty
– cellGame: Add missing game categories AT, AM and SG
– Fixed fs::rename
– Fixed crash in sys_tty_write() if the return buffer for the written length is NULL (Resident Evil 5 demo does this)
– Improve sys_fs_ftruncate: Handles stream API lock (EBUSY) and handles append mode
– sys_fs: use g_tls_error for diagnostic. Affected syscalls: sys_fs_open, sys_fs_opendir, sys_fs_stat, sys_fs_mkdir, sys_fs_fcntl (get free space)
– Implemented checks for FNID duplication
– Implemented MFF_HIDDEN for VNIDs (Now possible: « `REF_FUNC(…).flag(MFF_HIDDEN);`)
– Implemented syscalls _sys_prx_get_module_info, _sys_process_exit, _sys_prx_load_module_on_memcontainer, sys_ss_random_number_generator
– Fixed _sys_strncasecmp
– Exitspawn support renewal: Implemented _sys_process_exit2 syscall, Rewritten sys_game_process_exitspawn, Rewritten sys_game_process_exitspawn2, Implemented _sys_process_atexitspawn, Implemented _sys_process_at_Exitspawn and some other changes
– sys_fs_mkdir: implement ENOENT
– Fixed several filesystem errors where behavior differed a lot from a real PS3
– cellKb: Returns invalid parameter if port number is bigger than number of connected keyboards
– cellVdec: Added stolen TLS hack
– Fixed a callback regression on sceNpManager
– Fixed /dev_bdvd/ for exitspawn
– Fixed NPDRM exitspawn
– Changes CryptAcquireContextW to try CRYPT_NEWKEYSET flag if key container doesnt exist already
– Make cellMouseGetDataList return CELL_MOUSE_ERROR_NO_DEVICE if mouse handler is set to null

LLE
– Implemented LLE emulation of cellGcm
– Added libad_async, libad_billboard_util, libad_core to the list of modules to LLE. Makes several games start working with PPU Recompiler

RSX
– Fixed vertex decompiler to support two argument destinations
– Fixed a buffer overrun crash
– Re-implemented the weak vertex cache using unordered_map for faster search performance
– Re-implemented the texture cache also using unordered_map for faster search as well
– Properly synchronizes the texture cache to avoid random rsx lockup
– Implemented zcull occlusion stats using native occlusion queries
– Implemented conditional rendering as well using the emulated zcull unit
– Added conditional shared locks that take a flag for consideration to avoid recursive lock acquisition
– Yield instead of sleeping rsx thread
– Fixed a situation where a query read-back is requested while zcull render is still active
– Re-implemented the RSX driver side of the vertex processing stage. Vertex attribute data is no longer processed on the CPU freeing up resources otherwise used up dealing with this task. This moves a lot of work over GPU side and slow iGPUs might become a bottleneck. Due to the increased complexity of the shaders, a preloaded shader cache system is also included to allow the shader compilation and linking to happen outside of gameplay. This fixes the hitching and stuttering ingame at the cost of longer loading times. The cache can be deleted from the context menu
– Fixed immediate indexed rendering when immediate index array is provided but vertex data is sourced from registers and array inputs (Wolfenstein)
– Don’t keep invalidated objects around too long. Games like Tales of Vesperia seem to be using a random memory allocator with very low collision chance. This means objects are very unlikely to be reused in such games leading to pile-up
– Ignore sending system reserved semaphores to renderer
– Fixed sca register assignment in vertex decompiler. Fixes some vertex shaders: Text in little big planet and chunks of graphics in alteir games
– Implemented pixel size 16
– Minor improvements to shader cache to reduce first time compile stutter and number of pipeline objects
– Fixed VP ARL opcode: respect the vector write mask
– Implement QUAD_STRIP by redirecting to TRIANGLE_STRIP. This can fail in some rare cases, but that’s not something that can be fixed with indexing anyway. Quads are planar, but adjacent triangles need not be
– Added nullptr check on sys_rsx_context_attribute for games that call it before sys_rsx_memory_allocate. This inevitably caused RPCS3 to crash when it doesn’t on a PS3
– RSX thread recovery in the event of an unknown command [WIP, still dies/loops infinitely if unmapped addresses are provided]
– Unified texture cache for Vulkan and OpenGL. This means that any bugs fixed for one backend should carry over making development easier
– Implemented draw call batching for the slow games that would throw thousands of small draws at the hardware. Significantly speeds some some games. There is an AMD driver bug that will cause missing graphics but it has been reported upstream
– Added support for split draw ranges which would otherwise assert in RSXThread
– Fixed some shader decompiler bugs (DBZ Raging Blast games)
– Fixed section scanning range for early reject (fixes hands)
– Texture cache fixes: Updates section flags when requested, fixes nullptr dereference: cached_dest will be null if dst_is_render_target is true (fixes a crash in some games when using GPU texture scaling)
– Makes the 3rd texture dimension matter: Mark cube map and 3D textures as separate from 2D surfaces in the cache. Also adds an error if a type mismatch is detected
– Added support for internal resolution scaling. Compatible with most applications out-of-the-box. Note that strict rendering mode disables this scaling
– Enabled forced anisotropic filtering up to 16x
– Improves memory protection behavior when strict mode is off. Use full range protection without trampling shared pages instead of only checking a single page. This fixes some missing graphics in some games without requiring strict mode (id tech 5)
– When encountering corrupt put/get registers do not discard entire commandbuffers in case there are semaphores held
– Fixed src/dst framebuffer detection
– Fixed memory protection checks when strict mode is disabled. Should help prevent WCB from hanging the emulator
– Re-implements index buffer expansion/emulation and improves use of the primitive restart flag
– Fixed clear commands for depth-only passes. This removes the need for the invalidate cache hack
– Restructures the texture cache to contain section manipulation to one function
– Fixed some leaking memory sections
– Fixed surface subsection sampling (Turbo: Super Stunt Squad)
– Workaround fixes for crashes due to 0 pitch (VirtualMemory.cpp crash)
– Better detection of situations that would require memory stitching (framebuffer blit operations). Should fix black screen regressions in some games
– Disables draw call batching when strict mode is enabled. Strict mode should always use the safest option and the batching solution has been shown to fail in rare cases (Okami HD)
– Fixed a critical bug in volatile attribute layouts that was introduced during vertex rewrite but went unnoticed. Likely fixes corrupt graphics or black screen in some games, probably only affects 2D elements since it requires immediate-mode drawing plus at least one referenced data register to trigger this condition
– Invalidates surface store address when tile unbound
– Makes dmactrl get ‘readonly’: rsx accuracy change, currently its possible to edit the get ptr from the game side and cause the rsxthread to freak out. It should only be able to be changed from the syscall, so we use an internal variable to keep track of command buffer position and write it to get ptr now
– Tag framebuffer memory when strict mode is enabled to check if content has been written to. This way, framebuffer contents can be ignored if they are known to be incorrect
– Rework memory protection and ignore flush requests if the data has already been written to the CPU. Speedup when using WCB
– Prevents recursive access violations that cause hanging when WCB is enabled
– Tries to determine pixel offsets when nv308a::color is indexed with a non-zero y coordinate. Hopefully fixes bugs where shader ucode is not properly written to rsx mem leading to failing to compile shaders
– Only reject framebuffer memory if it appears inside an actual texture. Ideally should destroy such textures if they exist since the framebuffer will replace the data as it is rendered to, but such a case may not even exist in practice
– Reimplemented the fragment shader pipeline (partially) and optimized cache access
– Implemented texture data casts where possible (1D <-> 2D)
– Implemented render-to-cubemap [realtime reflections] (still incomplete, but should work most of the time)
– Fixes for texture size detection using rsx antialias modes
– Fixes for hanging when using WCB
– Workaround for AMD driver: Catch segfaults in wglDeleteContext with SEH. In rare cases the driver derefs a nullptr and dies, taking the emulator with it. From testing, it seems the vram is indeed freed when this happens so its « safe » to continue
– Disables blit operations if the target will have a size of 0 in any dimension. Fixes blit engine crashing when GPU texture scaling is disabled.
– Bumped shader cache ver to 1.1. Vertex input declarations (unused since vertex rewrite) and texture sampling coord type (unnormalized vs normalized) no longer affect shader state and do not generate new shaders. Shader cache should generate fewer shaders in affected titles
– Do not respect FENCx instructions as they seem to be an optimization hint. Respecting FENCx instructions can result in some hilariously broken shaders including entire shaders that are one big NOP

OpenGL
– Fixed an bug when initializing framebuffers
– Implemented a weak vertex cache for OpenGL as well
– Properly implement VSync control when using OpenGL
– Fixed a zcull corner case
– Fixes for backbuffer blits and complete removal of the flip hack when using OpenGL
– Removal of redundant classes in OpenGL and general cleanup of the texture framework for that backend. There were 2 separate texture classes for example with very different approaches which was awful
– Improved mesa compatibility for OpenGL
– Checks that fence is not empty before calling destroy (workaround for a driver bug)
– Removed the broken strict mode behavior of depth range using GL
– GLVertexDecompiler: fixes undeclared diff_color and spec_color by using mapped variable name, even if the register is declared as output and nothing is written to it
– Compatibility workarounds for AMD cards: emulates glMultiDrawArrays which are broken on Windows driver
– Optimized get_surface_subresource

Vulkan
– Fixed vertex buffer binding for Vulkan. The key is to avoid ‘stale’ descriptors getting to the driver since the referenced buffer views are likely to have been destroyed, resulting in a use-after-free promptly followed by a segfault
– Improvements to multithreaded vertex processing
– Volatile vertex cache implemented to help performance in geometry heavy scenes
– Pre-emptive framebuffer flushing to lower the penalty of a cache miss
– Partial rewrite of the Vulkan renderer to take advantage of parallel frame processing. The frame queue is now double-buffered improving performance and reducing stutter.
– Fixed windowed mode -> fullscreen mode transition hangs and crashes
– Implementation of blit engine in hardware for Vulkan backend
– Reorganization of frame storage and heap management for Vulkan [WIP, slight performance degradation]
– Optimize frame storage and minimize hard sync point occurrence. Improves framerates and makes frametimes a lot more consistent.
– Mark resources with frameIDs to keep drivers that buffer up frames from crashing (Mostly NVIDIA)
– Implemented VSync mode
– Fixed window resize race condition when doing flip
– Improved error handling, recovery and display when running Vulkan (NVIDIA fullscreen & window resize woes)
– Tightens VSync control to not accept any modes that would allow tearing – including adaptive VSync. The reason for this is that gcm is timed to control the virtual graphics controller instead of running uncapped and letting the display limit the framerate. This causes slight judder where the overhead of threads getting scheduled around means we might miss a present window. While the adaptive VSync does a good job allowing consistent frametimes, it does allow tearing to prevent judder. This forces true VSync. If you experience frame judder, disable the VSync option
– Implemented notifications from the GSFrame QWindow to the Vulkan renderer thread. It is important as the renderer should pause until resizing is complete to keep some drivers from crashing when the native window suddenly changes size in the middle of drawing/presenting
– Updateed the vulkan dependancies to the newer spec version. Moves KHR_external to core. Also makes it easier to use newer Vulkan SDK on which newer drivers are based upon. Overall a very minor update, hopefully nothing breaks
– Compatibility workarounds for AMD cards: disabled primitive restart on Vulkan
– Fixed clipping bug when using Vulkan + GPU texture scaling
– Flush command queue before attempting to perform texture writeback to guarantee draw order
– Tag primary command buffers with a flush_only access hint to ensure they are always reopened if submitted outside flush_command_queue such as when dealing with access violations
– Improved handling of swap_bytes behaviour when using WCB
Direct3D 12– Added [DO NOT USE] on D3D12 selection

Audio
– Implemented PulseAudio backend
– Added Buffer Count setting

Input
– DualShock 4: Fixed bluetooth connectivity bug on controller reconnect
– DualShock 4: Fixed initial connection issue and hotplug/dongle calibration detection
– evdev: Added evdev joystick support
– evdev: Better joystick axis scaling
– evdev: Fixes axis reversal
– evdev: Improved controller detection, this fixes detection of the Steam Controller when used with sc-controller
– evdev: Added deadzones
– evdev: Added analog to dpad option
– XInput: Added config entry for Pad Squircling Factor
– Added joystick squircling, which makes running in certain games nicer, same implementation as XInput and DualShock 4 backends
– Respects the controller setting when returning data from cellPadGetData
– Added a window to setup multiple input types as once
– All controllers are now handled by a single thread
– Added ignoring of emulator shortcuts to keyboard_pad_handler

Networking
– sys_net: Converts endianess before passing buffers to setsockopt
– sys_net full rewrite: Implement sys_net syscalls, Clean libnet functions, LLE load libnet.sprx, libhttp.sprx, libssl.sprx, librudp.sprx and libbeisobmf.sprx (makes basic applications like YouTube now work)
– Implemented SYS_NET_SO_REUSEPORT

Trophies
– Fixes rXml limitation
– Fixes sceNpTrophyCreateContext
– Implemented a basic trophy notification dialog
– Allows null argument in sceNpTrophyUnlockTrophy (fixes null dereference on Jak 2)
– Fixes for trophies to show correct language depending on set system language
– Implemented Trophy Manager
– Prevent TROPUSR from crashing on « bad » input

GUI
– Enabled modules list multiselection
– Added drag and drop to gamelist for PUP, PKG, RAP, Disc Game Directories and EBOOTs
– Adjusted toolbar size
– Fixed a bug that would crash the emulator on second boot
– Added user defined notes to saves on Savedata Manager
– Added the ability to force a log comment while a game is running on Alt+L
– Fixed scroller and splitter on debugger frame
– Added hidden by default debug tab in settings
– Fixed GuiSettings to be in config_path settings
– Fixed sort and scroll in game list
– Added smooth icon size slider
– Fixed settings dialog size to be consistent
– Added custom config indicator (gear icon)
– Added disable mouse input setting while the game screen is active (for those who play with UCR)
– Minor refactoring on pad settings
– Added git_branch to version, displays branch on GSFrame when not RPCS3/master and prints to log as well
– Fixed resize on boot
– Fixed custom config creation. It created the yml file right when opening the dialog. Now it creates it only on saving
– Added user custom theme Kuroi (Dark theme)
– Implemented save manager
– Hide Utilities by default (it’s displayed when Debug Tab is enabled)
– Forces single line text for out of bounds issue in Game List
– Fixed a layout bug in the Boot Recent menu
– Fixed small buttons/missing icons in the toolbar
– Fixed gamepad settings layout issue, added refresh button
– Added scrollbar to about dialog
– Fixed graphics adapter selection
– Added more customization options for styleshets
– Added char count label to osk dialog
– Fixed a bug in settings dialog layout
– Disabled viewport settings on custom configs
– Fixed fullscreen icon
– Added syntax highlighter for cg_disasm
– Show tooltips in description box when hovering settings
– Save manager improvements: Makes size only 60% height of window screen initially, adds ability to delete/select multiple rows, adds ability to open the directory of the save
– Debugger improvements: Repositioned the debugger’s current instruction to be in the middle, added a breakpoints list so one can see all the current breakpoints
– GSFrame: Identify minimize/restore events as separate from regular resize and do not react to them
– GSFrame: Enable message queue consumption after loading the shaders cache. Also hides the frame during this step. This fixes the ‘start fullscreen’ bug when running vulkan
– Updated Tooltips
– Added Delete LLVM Cache option

Windows
– Resets windows sleep timer on pad input (prevents computer from sleeping when playing with controller input only)
– Registered Win32 error 32 (Sharing Violation)
– Minor Windows fix on fs::truncate_file and fs::utime
– Fixed an issue where having paths on games.yml that point to NOT_READY drives such as empty physical/virtual disc drives returns ERROR_NOT_READY (Win32 error code 21) which was not handled in fs::error, therefore throwing an exception and crashing RPCS3

Linux
– Fixed saving/loading on Linux for some games by changing param.sfo to PARAM.SFO (lol)
– Finalized AppImage support, started providing proper Linux AppImages on rpcs3.net/download
– Fixed an LLVM issue on openSUSE Tumbleweed when using AMD by bundling Qt5Svg.so
– Fixed segmentation fault in boot recent list
– Fixed Fedora glew install instructions
– Make it pass desktop-file-validate in Ubuntu 14.04
– Added option to build using shared llvm libs for Gentoo users
– Added warning about needing to install libglvnd for NVIDIA linux users
– Implemented progress bar in taskbar
– Fixed some of libpng known incorrect profile spam
– Implemented set_native_priority (posix)

BSD
– Allows building with ALSA on BSD
– Makes Vulkan optional on Linux / makes it possible on FreeBSD. When the USE_Vulkan flag is on, finds the Vulkan loader using pkg-config, and uses it if it’s been found. Also libX11 is now linked on any non-Apple Unix. It was necessary on FreeBSD

Debug
– Added an option to disable the vertex cache for cases where it causes bugs
– Added SPU and PPU Debug checkboxes to Debug tab
– Added a CPU-only mode for debugging texture management operations. While it is quite accurate, it is not perfect and is as expected is slow. Should only be used for debugging
– Fixes debug counters for texture cache. Also tracks texture memory usage
– Added buffer names to vulkan heaps to help debug OOM crashes (« Working buffer not enough » crash)
– Added check_program_status time to draw call setup statistics. It can slow down games significantly
– Added PPU instruction stat dumper, needs PPU Debug option to activate and PPU Interpreter, dumps after Resume (after Pause)

Log
– Small improvements to error formatting on log
– Added CPU to log
– Compresses log to RPCS3.log.gz when closing RPCS3
– Makes it impossible to disable fatal errors logging
– Config now prints eventual errors for enums
– Backs up last log to old_logs/
– Fixed global variables in Log.cpp
– Added « Clear » option to TTY log context menu

Misc
– Added support for multi-files pkg
– Implemented log stacking for error report
– Removed several warnings from the code
– Allows project to be built on macOS with Clang. Only available Render there is Null
– Updated ffmpeg submodule
– Added experimental build warning for non-master builds
– Fixed rare occurence where there a /PS3_GAME+something directory lead to weird behavior
– Fix for unpkg
– Minor refactoring on GUI code for firmware libraries searching
– Fixes moving disc games with arbitrary dir name
– Adds specific how to ask for support instructions on fatal error dialog
– Travis.yml: Coverity and Coveralls code analysis are removed as they don’t work currently, « dist: trusty » is removed as it is now the default Linux, some rework and cleanup added
– Cleans up old wxWidgets related references
– Added some visual studio filters for GUI code files
– Document some of the build options in README and CMakeLists.txt
– VS build: Copies Qt5WinExtras.dll to bin directory. When building RPCS3 on Visual Studio, there’s some DLLs that are copied from the local QT installation to the RPCS3’s output directory using a
post-build script. However, one of these DLL was missing, which is required for running the program on debug mode (for release versions, the file is already present on git)
– Deploy QT DLLs using windeployqt tool: Replace the old mechanism that manually copy the DLLs using either CMake or VS built-in functions. The new approach uses the windeployqt tool provided by the QT project that automatically detect the needed DLLs and perform the necessary copying. This approach should be more robust if there’s an upstream change on QT project regarding DLLs usage
– Fixes an error when compiling with visual studio if you have other executables in the bin folder
– Added a GitHub issue template, hopefully helps with invalid issue spam
– Remove unused rsx-debugger submodule
– Change compiler requirements in cmake script to match with the values listed in the README file
– CMake: Builds LLVM from the submodule if there’s no suitable version
– Moves optional.hpp as a submodule
– Fixed travis trying to upload AppImage from private forks. Always fails if not from upstream repo anyway and detects as an error
– AppVeyor: The project is now built with the Visual Studio solution instead of CMake. This should prevent contributors using Linux (like myself) to introduce a regression on Windows by missing changes in the Visual Studio project files. The AppVeyor artifact is generated with Qt 5.9.1 (previously Qt 5.8) like for Travis. The version 5.9.1 of Qt is not mandatory, there is no problem to keep the minimal requirement to Qt 5.7 except maybe if we have bugs fixed in a newer version
– Finally fix version indicator. Now displays correct commit number instead of « 3 »

Página oficial:
https://rpcs3.net/

Lista de compatibilidad:
https://rpcs3.net/compatibility

Descarga Windows:
https://ci.appveyor.com/api/buildjobs/hkrc02f9cjc40u4n/artifacts/rpcs3-v0.0.4-2017-11-12-0064976c_win64.zip

Descarga Linux:
https://rpcs3.net/cdn/builds/rpcs3-v0.0.4-2017-11-12-0064976-8746_linux64.AppImage