armsx/ARMSX3
0
0
Fork 0
mirror of https://github.com/ARMSX2/ARMSX3.git synced 2026-08-24 16:58:52 -07:00
Code Issues Packages Projects Releases Wiki Activity

Fold build instructions into the README

Browse Source 
BUILDING.md was RPCS3's desktop build guide and had nothing about Android, so it
was misleading here. Removed it and put real Android build steps in the README
instead. Also dropped the status file, it was working notes and not much use to
anyone reading the repo.
This commit is contained in:
jpolo1224
2026-08-06 09:03:48 -04:00
parent 1eb63137e3
commit 30fc4e5663
3 changed files with 43 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ARMSX3-STATUS.md
-155
View File
@@ -1,155 +0,0 @@
# ARMSX3 — bring-up status
Session of 2026-08-05. Read this first.
## TL;DR
The native core builds against **upstream RPCS3**, not RPCSX. Our delta to upstream is
small and entirely guarded, which is the whole point: RPCSX is 1,960 commits and ~16
months behind upstream and is missing every one of whatcookie's 2026 ARM64 commits.
We get those for free and stay rebasable.
The Android app shell is forked from `rpcsx-ui-android` into `android/armsx3-app`,
rebranded, re-themed purple, and the ARMSX2 audio layer is ported in.
---
## The single most useful fact
**The app `dlopen()`s the core and resolves `_rpcsx_*` symbols via `dlsym`.**
`app/src/main/cpp/native-lib.cpp` loads a core `.so` at runtime — that is why
rpcsx-build publishes 7 `-march` variants (armv8-a … armv9.1-a) and the app picks one.
Our core exports **26/26** of the symbols the shell dlsyms. Verified compatible.
So `librpcsx-android.so` drops into the existing shell unchanged — you do not need
any UI work to get a build that boots games.
---
## Upstream files we modified (keep this list near zero)
| File | Lines | Why |
|---|---|---|
| `CMakeLists.txt` | 6 | `if(ANDROID)` include ffmpeg.cmake before 3rdparty; add `android/` subdir |
| `rpcs3/Emu/Io/pad_config_types.h` | 3 | `#ifdef __ANDROID__ virtual_pad` enum value |
| `rpcs3/Emu/Io/pad_config_types.cpp` | 3 | matching `fmt_class_string` case — **without this the value serialises as `unknown` and the handler silently never gets selected** |
| `3rdparty/CMakeLists.txt` | 6 | expose OpenAL headers on Android (see below) |
| `rpcs3/util/media_utils.cpp` | 3 | `#include "util/ffmpeg_compat.h"` |
Everything else is additive: `android/`, `rpcs3/dev/`, `rpcs3/Input/virtual_pad_handler.*`,
`rpcs3/util/ffmpeg_compat.h`.
## Traps found the hard way (do not re-derive these)
1. **NDK 29 / clang 21 is required. NDK 28.2 is clang 19.0.1 and will not build this.**
`fmt::throw_exception` is a CTAD struct whose ctor *and* dtor are `[[noreturn]]`, not a
function. clang 19.0.1 fails to propagate that, so every `default:` ending in it trips
`-Werror,-Wreturn-type`. It killed 4 TUs at 2510/3123 — *after* LLVM had fully built.
Do **not** silence it with `-Wno-error=return-type`; the code is correct.
Cheap way to test a toolchain hypothesis without a 30-min rebuild: pull the failing
compile line out of the ninja log, `sed` the compiler+sysroot to the other NDK, strip
`-o/-MD/-MT/-MF`, add `-fsyntax-only`. 30 seconds instead of 30 minutes.
2. **Never make `android/` the top-level CMake project** (RPCSX does). Upstream assumes
`CMAKE_SOURCE_DIR == repo root` in ≥4 places (`FindWolfSSL.cmake`, `FindZLIB.cmake`,
`3rdparty/protobuf`, `3rdparty/llvm`). Configuring with `-S android` makes them all
resolve to `android/3rdparty/...`. Configure from root; use `android/configure.sh`.
3. **Upstream pins LLVM 22.x.** RPCSX's prebuilt `llvm-android-arm64-v8a` is 20.1.3 — two
majors behind, unusable (ORC/JIT API breaks). Must build from source.
4. **Upstream's Android path is half-finished in two places.** Its ffmpeg block is
`if(NOT ANDROID)` but it aliases `3rdparty::ffmpeg` **unguarded**. Its OpenAL branch
defines `WITHOUT_OPENAL=1` but exposes no include dir, while `cellMic.h` includes
`alc.h` unconditionally (the *calls* are guarded — 7 sites in cellMic.cpp — only the
include is not).
5. **ffmpeg**: upstream targets 7.1+ APIs (`avcodec_get_supported_config`/`AVCodecConfig`,
const `AVChannelLayout*`). The only Android prebuilt in existence is 5.1. Stopgap is
`rpcs3/util/ffmpeg_compat.h`, version-gated so it self-disables. **Real fix: cross-compile
ffmpeg 7.1 for Android, then delete that header and its one `#include`.**
---
## Done
- `agents/ARMSX3` on upstream RPCS3 `652cf60bf`, branch `armsx3-bringup`,
remotes `upstream`=RPCS3, `rpcsx`=RPCSX.
- Android layer ported: 43/55 of RPCSX's includes resolved untouched, 9 mechanical
remaps, 3 `rx::` calls → `utils::trap()` / `rpcs3::get_version()`.
- `android/configure.sh` — reproducible configure with every cross-compile override
documented inline (`USE_NATIVE_INSTRUCTIONS=OFF` matters: it means `-march=native`,
which probes the *host* Mac).
- App shell forked to `android/armsx3-app`, `applicationId = com.armsx3`, name ARMSX3.
- **Purple Material3 theme** seeded from the logo, both light and dark.
- **Audio ported from ARMSX2 mono**: `MenuSfx.kt`, `LibraryMusic.kt`, `PauseMusic.kt`
+ 14 SFX wavs + pause music. `MainActivityRuntime.prefs` → `GeneralSettings.raw`
(new accessor on the same `app_prefs` store); `EmuState` → RPCSX's `EmulatorState`.
- Your track re-encoded 320kbps/7.2MB → 128k/3.6MB as `res/raw/library_music.m4a`.
- `CoverRepository.kt` written for aldostools covers.
## Covers — measured, not assumed
`https://raw.githubusercontent.com/aldostools/Resources/main/COV/<TITLE_ID>.JPG`
Flat layout, `TITLE_ID` is exactly what PARAM.SFO gives (`BLUS30443`). Verified 200s.
- Covers are **260×300, aspect 0.866** — multiMAN style, **not** the ~0.72 PS3 retail
sleeve ratio. Draw at `CoverRepository.COVER_ASPECT` or everything letterboxes.
- **There are no 3D covers in that repo**, so that feature is out, as you said.
- Repo is 3.1 GB — fetch per-title, never clone. `CoverRepository` caches to
`filesDir/covers`, writes a `.miss` marker on 404 so coverless titles aren't
re-requested forever, and downloads via `.part`+rename so an interrupted fetch
can't leave a truncated jpg that looks valid.
## Not done — and why
- **Setup/onboarding screen.** rpcsx-ui-android has *none* (no Setup/Onboard/Welcome
files; `startDestination = "games"`, missing firmware is just a nag dialog in
GamesScreen). ARMSX2's `ui/onboarding/` is 1,039 lines and depends on `ArmsBackdrop`,
`ArmsLogo`, `StatusChip`, `padFocusRing`, i18n.
**This is not a rename job**: PS2 BIOS is a ROM file you point at; PS3 firmware is a
PUP you *install* and decrypt into `dev_flash`. `BiosInfo` (ROMVER region byte, packed
version) has no PS3 analogue. The RPCS3 side is `installFw(fd, progressId)` +
`FirmwareRepository{None,Installed,Compiled}` + `utils::get_firmware_version()`.
- Shaders, controller skins, cover UI wiring, perf tab, save-state UI, touch controls
reconcile — all mapped below, none ported yet.
- RetroAchievements — **dropped**, RA has no PS3 support.
## Port map (ARMSX2 mono → ARMSX3)
Source root: `agents/armsx2-push-staging/platforms/android/app/src/main/java/com/armsx2`
| Feature | Files |
|---|---|
| Shaders | `ShaderRepo.kt`, `ShaderParams.kt`, `ui/common/ShaderChainSection.kt`, `ShaderManagerSection.kt`, `ShaderParamsEditor.kt` |
| Controller skins | `ControllerSkinStore.kt`, `SkinRepo.kt`, `ui/settings/SkinsTab.kt` |
| Covers UI | `CoverRegionIndex.kt`, `ui/common/GameCoverArt.kt` |
| Custom drivers | `CustomDriver.kt`, `ui/common/DriverManagerSection.kt` — **reconcile, don't port**: RPCSX already has adrenotools + `GpuDriversScreen` |
| Save states | `ui/saves/SaveManagerScreen.kt`, `SaveStatePicker.kt` (core already has savestates) |
| Perf | `ui/settings/PerformanceTab.kt` |
| Touch | `ui/touch/TouchControls.kt`, `GestureLayer.kt`, `LightgunLayer.kt` — reconcile with RPCSX's `PadOverlay*` (7 files) + `OverlayEditActivity` |
| Theme | `ui/theme/Color.kt`, `Theme.kt`, `Type.kt` |
| Settings search | `ui/settingshub/SettingsSearchOverlay.kt` |
## Already free — do not rebuild these
**Core (upstream RPCS3):** Vulkan (29 files), OpenGL (18), `video_renderer{null,opengl,vulkan}`,
save states, and perf knobs incl. **Frame limit** (fps cap), **Sleep Timers Accuracy**,
**Thread Scheduler Mode**, framerate/frametime graphs.
**RPCSX UI:** touch controls (7 files), **layout editor** (5), adrenotools custom-driver
loading + driver UI (6), PS3 firmware install (5), SAF provider, USB, PPU precompile
service, surface handling.
## Open items needing you
1. **Logo** — I can't write an image from chat to disk. Drop the 512×512 at
`~/Downloads/armsx3-logo.png` and it gets wired to launcher icon + onboarding.
2. **`kr.co.iefriends.pcsx2.NativeApp`** is imported by ARMSX2's `config/Settings.kt` —
a *different* rights holder from you. Must be replaced before that file crosses over.
(You confirmed you hold the rest of the ARMSX2 UI rights.)
3. **`Bin2Pbp.7z`** — that's a PS1→PSP EBOOT tool, unrelated to PS3. Left untouched;
assumed an accidental attach.
4. **Licensing**: RPCS3 is **GPL-2.0-only** (stated in its README). ARMSX2 is GPL-3.0.
Incompatible. Since you hold the ARMSX2 UI rights, ARMSX3's UI needs to go out under
GPL-2.0-only to combine with the core.
BUILDING.md
-193
View File
@@ -1,193 +0,0 @@
# Building
Only Windows and Linux are officially supported for building. However, various other platforms are capable of building RPCS3.
Other instructions may be found [here](https://wiki.rpcs3.net/index.php?title=Building).
## Setup your environment
### Windows 10 or later
The following tools are required to build RPCS3 on Windows 10 or later:
- [Visual Studio 2022/2026](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community)
- **Optional** - [CMake 3.28.0+](https://www.cmake.org/download/) (add to PATH)
**NOTES:**
- **Visual Studio 2026** needs at least **CMake 4.2.0+**.
- **Visual Studio 2022/2026** integrates **CMake 3.29+** and it also supports both the `sln` solution (`.sln`, `.vcxproj`) and `CMake` solution (`CMakeLists.txt`, `CMakePresets.json`).
See sections [Building with Visual Studio sln solution](#building-with-visual-studio-sln-solution) and [Building with Visual Studio CMake solution](#building-with-visual-studio-cmake-solution)
on how to build the project with **Visual Studio**.
- Install and use this standalone **CMake** tool just in case of your preference. See section [Building with standalone CMake tool](#building-with-standalone-cmake-tool) on how to build the project
with standalone **CMake** tool.
- [Python 3.6+](https://www.python.org/downloads/) (add to PATH)
- [Qt 6.11.1](https://www.qt.io/download-qt-installer) In case you can't download from the official installer, you can use [Another Qt installer](https://github.com/miurahr/aqtinstall) (In that case you will need to manually add the "qtmultimedia" module when installing Qt)
- [Vulkan SDK 1.4.341.1](https://vulkan.lunarg.com/sdk/home) (see "Install the SDK" [here](https://vulkan.lunarg.com/doc/sdk/latest/windows/getting_started.html)). Note that future SDKs may not work.
The `sln` solution available only on **Visual Studio** is the preferred building solution. It easily allows to build the **RPCS3** application in `Release` and `Debug` mode.
In order to build **RPCS3** with the `sln` solution (with **Visual Studio**), **Qt** libs need to be detected. To detect the libs:
- add and set the `QTDIR` environment variable, e.g. `<QtInstallFolder>\6.11.1\msvc2022_64\`
- or use the [Visual Studio Qt Plugin](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.QtVisualStudioTools2022)
**NOTE:** If you have issues with the **Visual Studio Qt Plugin**, you may want to uninstall it and install the [Legacy Qt Plugin](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.LEGACYQtVisualStudioTools2022) instead.
In order to build **RPCS3** with the `CMake` solution (with both **Visual Studio** and standalone **CMake** tool):
- add and set the `Qt6_ROOT` environment variable to the **Qt** libs path, e.g. `<QtInstallFolder>\6.11.1\msvc2022_64\`
### Linux
These are the essentials tools to build RPCS3 on Linux. Some of them can be installed through your favorite package manager:
- Clang 17+ or GCC 13+
- [CMake 3.28.0+](https://www.cmake.org/download/)
- [Qt 6.11.1](https://www.qt.io/download-qt-installer)
- [Vulkan SDK 1.4.341.1](https://vulkan.lunarg.com/sdk/home) (See "Install the SDK" [here](https://vulkan.lunarg.com/doc/sdk/latest/linux/getting_started.html)). Note that future SDKs may not work.
- [SDL3](https://github.com/libsdl-org/SDL/releases) (for the FAudio backend)
**If you have an NVIDIA GPU, you may need to install the libglvnd package.**
#### Arch Linux
sudo pacman -S glew openal cmake ninja vulkan-validation-layers qt6-base qt6-declarative qt6-multimedia qt6-svg sdl3 sndio jack2 base-devel
#### Debian & Ubuntu
sudo apt-get install build-essential ninja-build libasound2-dev libpulse-dev libopenal-dev libglew-dev zlib1g-dev libedit-dev libvulkan-dev libudev-dev git libevdev-dev libsdl3-dev libjack-dev libsndio-dev libcurl4-openssl-dev qt6-base-dev qt6-base-private-dev qt6-multimedia-dev qt6-svg-dev libxkbcommon-dev
Ubuntu is usually horrendously out of date, and some packages need to be downloaded by hand. This part is for Qt, GCC, Vulkan, and CMake
##### Qt PPA
Ubuntu usually does not have a new enough Qt package to suit rpcs3's needs. There is currently no PPA available to work around this.
##### GCC 13.x installation
If the `gcc-13` package is not available on your system, use the following commands
```
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt-get update
sudo apt-get install gcc-13 g++-13
```
You can either use `update-alternatives` to setup `gcc-13`/`g++-13` as your default compilers or prefix the `cmake` build file generation command by `CXX=g++-13 CC=gcc-13` to use it.
##### Vulkan SDK
For Ubuntu systems, it is strongly recommended to use the PPA from [LunarG](https://packages.lunarg.com/) which will provide a compatible Vulkan SDK to compile RPCS3. If your Vulkan SDK is older, it can lead to compilation errors.
```
. /etc/os-release
wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | sudo apt-key add -
sudo wget -qO /etc/apt/sources.list.d/lunarg-vulkan-1.3.268-$UBUNTU_CODENAME.list https://packages.lunarg.com/vulkan/1.3.268/lunarg-vulkan-1.3.268-$UBUNTU_CODENAME.list
sudo apt update
sudo apt install vulkan-sdk
```
##### CMake
```
. /etc/os-release
wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | sudo apt-key add -
sudo apt-add-repository "deb https://apt.kitware.com/ubuntu/ $UBUNTU_CODENAME main"
sudo apt-get update
sudo apt-get install kitware-archive-keyring
sudo apt-key --keyring /etc/apt/trusted.gpg del C1F34CDD40CD72DA
sudo apt-get install cmake
```
#### Fedora
sudo dnf install alsa-lib-devel cmake ninja-build glew glew-devel libatomic libevdev-devel libudev-devel openal-soft-devel qt6-qtbase-devel qt6-qtbase-private-devel vulkan-devel pipewire-jack-audio-connection-kit-devel qt6-qtmultimedia-devel qt6-qtsvg-devel llvm-devel libcurl-devel
#### OpenSUSE
sudo zypper install git cmake ninja libasound2 libpulse-devel openal-soft-devel glew-devel zlib-devel libedit-devel vulkan-devel libudev-devel libqt6-qtbase-devel libqt6-qtmultimedia-devel libqt6-qtsvg-devel libQt6Gui-private-headers-devel libevdev-devel libsndio7_1 libjack-devel
## Setup the project
Clone and initialize the repository
```bash
git clone --recurse-submodules https://github.com/RPCS3/rpcs3.git
cd rpcs3
git submodule sync
# This is automatically done by `git clone --recurse-submodules`,
# but in case you forgot it, you can manually fetch submodules this way:
git submodule update --init --recursive
```
### Windows
#### Building with Visual Studio sln solution
Start **Visual Studio**, click on `Open a project or solution` and select the `rpcs3.sln` file inside the RPCS3's root folder
##### Configuring the Qt Plugin (if used)
1) go to `Extensions->Qt VS Tools->Qt Versions`
2) add the path to your Qt installation with compiler e.g. `<QtInstallFolder>\6.11.1\msvc2022_64`, version will fill in automatically
3) go to `Extensions->Qt VS Tools->Options->Legacy Project Format`. (Only available in the **Legacy Qt Plugin**)
4) set `Build: Run pre-build setup` to `true`. (Only available in the **Legacy Qt Plugin**)
##### Building the projects
**NOTE:** The recommended build configuration is `Release`. (On older revisions: `Release - LLVM`)
To speed up the compilation time, you may want to download and extract to `<rpcs3_root>\build\lib_ext\<$(Configuration)>-x64` (e.g. `c:\rpcs3\build\lib_ext\Release-x64`; the path needs to be created) the following precompiled lib:
- [LLVM libs](https://github.com/RPCS3/llvm-mirror/releases/download/custom-build-win-22.1.8/llvmlibs_mt.7z)
**NOTES:**
- `<$(Configuration)>` can assume values `Release` or `Debug`.
- Unoptimised/debug libs are currently not available precompiled for **LLVM**. Trying to use it when building the **RPCS3** application in `Debug` mode will provide a `cannot open file` error.
If you're not using the precompiled libs, those dependency libs need to be compiled first. From the `Solution Explorer` panel:
1) expand `__BUILD_BEFORE`
2) from the `Solution Configurations` drop-down menu, select `Release` (select `Debug` if you want to build in `Debug` mode)
3) right-click one of the following projects and then click on `Build` to build the selected lib:
- `llvm_build`
- or `llvm_build_clang_cl` (if you have also the **clang** compiler installed on VS)
**NOTE:** Compiled dependency libs have priority over precompiled libs, if installed. It means that they will always be referenced and linked in case the precompiled libs are also available.
In order to build the **RPCS3** application:
1) from the `Solution Configurations` drop-down menu, select `Release` (select `Debug` if you want to build in `Debug` mode)
**NOTE:** In case you previously compiled the dependency libs under `__BUILD_BEFORE`, you have also to select the same build configuration (e.g. `Release`, if you compiled the dependency libs in `Release` mode)
2) click on `Build` menu and then on `Build Solution`
3) once the build is completed, the **RPCS3** application will be available under the `<rpcs3_root>\bin` folder
#### Building with Visual Studio CMake solution
Start **Visual Studio**, click on `Open a local folder` and select the RPCS3's root folder
Once the project is open on VS, from the `Solution Explorer` panel:
1) right-click on `rpcs3` and then click on `Switch to CMake Targets View`
2) from the `Configuration` drop-down menu, select `msvc-release` (select `msvc-debug` if you want to build in `Debug` mode)
3) right-click on `CMakeLists.txt Project` and then click on `Configure Cache`
4) once the cache is created, the `rpcs3 project` will be available
5) right-click on `rpcs3 Project` and then click on `Build All`, or click on `Build` menu and then on `Build All`
6) once the build is completed, the **RPCS3** application will be available under the `<rpcs3_root>\build-msvc\bin` folder
#### Building with standalone CMake tool
In case you preferred to install and use the standalone **CMake** tool:
1) move on the RPCS3's root folder
2) execute the following commands to create the cache and to build the application (for the build, use `--preset msvc-debug` if you want to build in `Debug` mode), respectively:
```
cmake --preset msvc
cmake --build --preset msvc-release
```
3) once the build is completed, the **RPCS3** application will be available under the `<rpcs3_root>\build-msvc\bin` folder
### Linux
While still in the project root:
1) `cmake -B build -G Ninja` to generate build files with the default compiler (override the compiler by prepending e.g. `CC=clang CXX=clang++`)
2) `cmake --build build` to compile
3) run RPCS3 with `build/bin/rpcs3`
If compiling for ARM, pass the flag `-DUSE_NATIVE_INSTRUCTIONS=OFF` to the first `cmake` command. This resolves some NEON errors when compiling our SIMD headers.
When using GDB, configure it to ignore SIGSEGV signal (`handle SIGSEGV nostop noprint`).
If desired, use the various build options in [CMakeLists](https://github.com/RPCS3/rpcs3/blob/master/CMakeLists.txt).
README.md
+43 -2
View File
@@ -39,10 +39,51 @@ Android:
Building
--------
See BUILDING.md.
Only arm64-v8a is supported. You need the Android SDK with NDK r27 or newer,
CMake 3.30 or newer, and a JDK 17. Android Studio ships all of these.
Clone with submodules, then fetch the two third party checkouts that are not
submodules:
git clone --recursive https://github.com/ARMSX2/ARMSX3.git
cd ARMSX3
git clone https://github.com/SnowflakePowered/librashader 3rdparty/librashader
git clone https://github.com/bylaws/libadrenotools android/armsx3-ui/app/src/main/cpp/libadrenotools
Build the core. This is the long part and produces an unstripped library of
around 1.3 GB:
export ANDROID_HOME=$HOME/Library/Android/sdk
cmake -B build-android -G Ninja \
-DCMAKE_TOOLCHAIN_FILE=$ANDROID_HOME/ndk/<version>/build/cmake/android.toolchain.cmake \
-DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-31 \
-DCMAKE_BUILD_TYPE=RelWithDebInfo
cmake --build build-android --target rpcsx-android -j8
Strip it and put it where the app expects it:
llvm-strip --strip-unneeded build-android/android/libarmsx3-core.so
cp build-android/android/libarmsx3-core.so \
android/armsx3-ui/app/src/main/jniLibs/arm64-v8a/
Then build the app:
cd android/armsx3-ui
export JAVA_HOME="/Applications/Android Studio.app/Contents/jbr/Contents/Home"
./gradlew :app:assembleRelease
The apk lands in app/build/outputs/apk/release/.
Note that the core library has to be rebuilt and copied again whenever anything
under rpcs3/ or android/src/ changes. Gradle does not build it for you.
The Discord Social SDK is proprietary and is not redistributed here. Get it from
Discord's developer portal if you want that feature.
Discord's developer portal and drop it in app/libs/ and
app/src/main/cpp/discord_sdk/ if you want that feature. The build skips it
otherwise.
Running it needs PS3 firmware, which is not included. Install PS3UPDAT.PUP from
Sony's support site through the setup screen in the app.
License
-------