hackern64/ultrasm64-2
0
0
Fork 0
mirror of https://github.com/HackerN64/ultrasm64-2.git synced 2026-01-21 10:38:08 -08:00
Code Issues Packages Projects Releases Wiki Activity

Refresh 10

Browse Source
This commit is contained in:
n64
2020-06-02 12:44:34 -04:00
parent e58669b4b3
commit d43d9b7f20
444 changed files with 30163 additions and 7628 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
README.md
View File

@@ -1,9 +1,8 @@
# Super Mario 64
This repo contains a full decompilation of Super Mario 64 (J), (U), and (E).
The source and data have been decompiled but complete naming and documentation
all of the code and data is still a work in progress. Decompiling the Shindou ROM
is also an ongoing effort.
- This repo contains a full decompilation of Super Mario 64 (J), (U), and (E) with minor exceptions in the audio subsystem.
- Naming and documentation of the source code and data structures are in progress.
- Efforts to decompile the Shindou ROM steadily advance toward a matching build.
It builds the following ROMs:
@@ -12,65 +11,60 @@ It builds the following ROMs:
* sm64.eu.z64 `sha1: 4ac5721683d0e0b6bbb561b58a71740845dceea9`
This repo does not include all assets necessary for compiling the ROMs.
A prior copy of the game is required to extract the required assets.
A prior copy of the game is required to extract the assets.
## Quick Start (for Ubuntu)
1. Install prerequisites: `sudo apt install -y build-essential git binutils-mips-linux-gnu python3 libaudiofile-dev`
2. Clone the repo from within Linux: `git clone https://github.com/n64decomp/sm64.git`
3. Place a Super Mario 64 ROM called `baserom.<VERSION>.z64` into the project folder for asset extraction, where `VERSION` can be `us`, `jp`, or `eu`.
4. Run `make` to build. Qualify the version through `make VERSION=<VERSION>`. Add `-j4` to improve build speed (hardware dependent).
Ensure the repo path length does not exceed 255 characters. Long path names result in build errors.
## Installation
### Docker
### Windows
#### 1. Copy baserom(s) for asset extraction
Install WSL and a distro of your choice following
[Windows Subsystem for Linux Installation Guide for Windows 10.](https://docs.microsoft.com/en-us/windows/wsl/install-win10)
We recommend either Debian or Ubuntu 18.04 Linux distributions under WSL.
Note: WSL1 does not currently support Ubuntu 20.04.
For each version (jp/us/eu) that you want to build a ROM for, put an existing ROM at
`./baserom.<version>.z64` for asset extraction.
Next, clone the SM64 repo from within the Linux shell:
`git clone https://github.com/n64decomp/sm64.git`
#### 2. Create docker image
```bash
docker build -t sm64 .
```
#### 3. Build
To build we simply have to mount our local filesystem into the docker container and build.
```bash
# for example if you have baserom.us.z64 in the project root
docker run --rm --mount type=bind,source="$(pwd)",destination=/sm64 sm64 make VERSION=us -j4
# if your host system is linux you need to tell docker what user should own the output files
docker run --rm --mount type=bind,source="$(pwd)",destination=/sm64 --user $UID:$UID sm64 make VERSION=us -j4
```
Resulting artifacts can be found in the `build` directory.
Then continue following the directions in the [Linux](#linux) installation section below.
### Linux
#### 1. Copy baserom(s) for asset extraction
There are 3 steps to set up a working build.
For each version (jp/us/eu) that you want to build a ROM for, put an existing ROM at
`./baserom.<version>.z64` for asset extraction.
#### 2. Install build dependencies
#### Step 1: Install dependencies
The build system has the following package requirements:
* binutils-mips >= 2.27
* binutils-mips
* python3 >= 3.6
* libaudiofile
* qemu-irix
__Debian / Ubuntu__
Dependency installation instructions for common Linux distros are provided below:
##### Debian / Ubuntu
To install build dependencies:
```
sudo apt install build-essential pkg-config git binutils-mips-linux-gnu python3 zlib1g-dev libaudiofile-dev
sudo apt install -y build-essential git binutils-mips-linux-gnu python3 libaudiofile-dev
```
Download latest package from [qemu-irix Releases](https://github.com/n64decomp/qemu-irix/releases)
Download latest package from [qemu-irix Releases.](https://github.com/n64decomp/qemu-irix/releases)
Install this package with:
```
sudo dpkg -i qemu-irix-2.11.0-2169-g32ab296eef_amd64.deb
```
(Optional) Clone https://github.com/n64decomp/qemu-irix and follow the install instructions in the README.
__Arch Linux__
##### Arch Linux
To install build dependencies:
```
sudo pacman -S base-devel python audiofile
```
@@ -78,29 +72,70 @@ Install the following AUR packages:
* [mips64-elf-binutils](https://aur.archlinux.org/packages/mips64-elf-binutils) (AUR)
* [qemu-irix-git](https://aur.archlinux.org/packages/qemu-irix-git) (AUR)
#### 3. Build ROM
Run `make` to build the ROM (defaults to `VERSION=us`). Make sure your path to the repo
is not too long or else this process will error, as the emulated IDO compiler cannot
handle paths longer than 255 characters.
Examples:
##### Other Linux distributions
Most modern Linux distributions should have equivalent packages to the other two listed above.
You may have to use a different version of GNU binutils. Listed below are fully compatible binutils
distributions with support in the makefile, and examples of distros that offer them:
* `mips64-elf-` (Arch AUR)
* `mips-linux-gnu-` (Ubuntu and other Debian-based distros)
* `mips64-linux-gnu-` (RHEL/CentOS/Fedora)
You may also use [Docker](#docker-installation) to handle installing an image with minimal dependencies.
#### Step 2: Copy baserom(s) for asset extraction
For each version (jp/us/eu) for which you want to build a ROM, put an existing ROM at
`./baserom.<VERSION>.z64` for asset extraction.
##### Step 3: Build the ROM
Run `make` to build the ROM (defaults to `VERSION=us`).
Other examples:
```
make VERSION=jp -j4 # build (J) version instead with 4 jobs
make VERSION=eu COMPARE=0 # non-matching EU version still WIP
make VERSION=eu COMPARE=0 # build (EU) version but do not compare ROM hashes
```
## Windows
Resulting artifacts can be found in the `build` directory.
For Windows, install WSL and a distro of your choice following
[Windows Subsystem for Linux Installation Guide for Windows 10](https://docs.microsoft.com/en-us/windows/wsl/install-win10)
We recommend either Debian or Ubuntu 18.04 Linux distributions under WSL.
The full list of configurable variables are listed below, with the default being the first listed:
Then follow the directions in the [Linux](#linux) installation section above.
* ``VERSION``: ``us``, ``jp``, ``eu``, ``sh`` (WIP)
* ``GRUCODE``: ``f3d_old``, ``f3d_new``, ``f3dex``, ``f3dex2``, ``f3dzex``
* ``COMPARE``: ``1`` (compare ROM hash), ``0`` (do not compare ROM hash)
* ``NON_MATCHING``: Use functionally equivalent C implementations for non-matchings. Also will avoid instances of undefined behavior.
* ``CROSS``: Cross-compiler tool prefix (Example: ``mips64-elf-``).
* ``QEMU_IRIX``: Path to a ``qemu-irix`` binary.
## macOS
### macOS
macOS is currently unsupported as qemu-irix is unable to be built for macOS host.
The recommended path is installing a Linux distribution under a VM.
Installing Docker is the recommended avenue for macOS users. This project does not support macOS natively due to lack of macOS host support.
### Docker Installation
#### Create Docker image
Create the docker image with `docker build -t sm64`.
#### Build
To build, mount the local filesystem into the Docker container and build the ROM with `docker run`.
##### macOS example for (U):
```
docker run --rm --mount type=bind,source="$(pwd)",destination=/sm64 sm64 make VERSION=us -j4
```
##### Linux example for (U):
For a Linux host, Docker needs to be instructed which user should own the output files:
```
docker run --rm --mount type=bind,source="$(pwd)",destination=/sm64 --user $UID:$UID sm64 make VERSION=us -j4
```
Resulting artifacts can be found in the `build` directory.
## Project Structure
@@ -108,11 +143,11 @@ The recommended path is installing a Linux distribution under a VM.
sm64
├── actors: object behaviors, geo layout, and display lists
├── asm: handwritten assembly code, rom header
│   └── non_matchings: asm for non-matching sections
│ └── non_matchings: asm for non-matching sections
├── assets: animation and demo data
│   ├── anims: animation data
│   └── demos: demo data
├── bin: asm files for ordering display lists and textures
│ ├── anims: animation data
│ └── demos: demo data
├── bin: C files for ordering display lists and textures
├── build: output directory
├── data: behavior scripts, misc. data
├── doxygen: documentation infrastructure
@@ -120,14 +155,15 @@ sm64
├── include: header files
├── levels: level scripts, geo layout, and display lists
├── lib: SDK library code
├── rsp: audio and Fast3D RSP assembly code
├── sound: sequences, sound samples, and sound banks
├── src: C source code for game
│   ├── audio: audio code
│   ├── buffers: stacks, heaps, and task buffers
│   ├── engine: script processing engines and utils
│   ├── game: behaviors and rest of game source
│   ├── goddard: Mario intro screen
│   └── menu: title screen and file, act, and debug level selection menus
│ ├── audio: audio code
│ ├── buffers: stacks, heaps, and task buffers
│ ├── engine: script processing engines and utils
│ ├── game: behaviors and rest of game source
│ ├── goddard: Mario intro screen
│ └── menu: title screen and file, act, and debug level selection menus
├── text: dialog, level names, act names
├── textures: skybox and generic texture data
└── tools: build tools
@@ -138,6 +174,6 @@ sm64
Pull requests are welcome. For major changes, please open an issue first to
discuss what you would like to change.
Run clang-format on your code to ensure it meets the project's coding standards.
Run `clang-format` on your code to ensure it meets the project's coding standards.
Official Discord: https://discord.gg/DuYH3Fh