├── .gitignore ├── .gitmodules ├── Makefile ├── README.md ├── diff ├── diff.py ├── diff_settings.py ├── first_diff.py ├── include ├── 2.0I │ ├── PR │ │ ├── PRimage.h │ │ ├── R4300.h │ │ ├── abi.h │ │ ├── gbi.h │ │ ├── gs2dex.h │ │ ├── gt.h │ │ ├── gu.h │ │ ├── libaudio.h │ │ ├── mbi.h │ │ ├── n_libaudio.h │ │ ├── n_libaudio_s_to_n.h │ │ ├── os.h │ │ ├── os_internal.h │ │ ├── ramrom.h │ │ ├── rcp.h │ │ ├── rdb.h │ │ ├── region.h │ │ ├── rmon.h │ │ ├── sched.h │ │ ├── sp.h │ │ ├── sptask.h │ │ ├── ucode.h │ │ ├── ultraerror.h │ │ ├── ultralog.h │ │ ├── ultratypes.h │ │ └── uportals.h │ ├── assert.h │ ├── bstring.h │ ├── ultra64.h │ └── ultrahost.h ├── audio.h ├── audio_syms.h ├── bss.h ├── gameplay.h ├── gfx.h ├── include_asm.h ├── macro.inc ├── macros.h ├── materials.h ├── mathutils.h ├── mem.h ├── mus │ ├── libmus.h │ ├── libmus_config.h │ ├── libmus_data.h │ ├── n_libaudio_sc.h │ ├── n_libaudio_sn_sc.h │ ├── player.h │ └── player_fifo.h ├── sounds.h └── types.h ├── progress.py ├── sn ├── asn64.exe ├── cc1n64.exe ├── ccn64.exe ├── cppn64.exe └── sn.ini ├── src ├── lib │ ├── codeseg1 │ │ ├── aud_dma.c │ │ ├── aud_dma.h │ │ ├── aud_samples.c │ │ ├── aud_samples.h │ │ ├── aud_sched.c │ │ ├── aud_sched.h │ │ ├── aud_thread.c │ │ ├── aud_thread.h │ │ ├── lib_memory.c │ │ ├── lib_memory.h │ │ ├── player.c │ │ ├── player_api.c │ │ ├── player_commands.c │ │ ├── player_fifo.c │ │ ├── player_fx.c │ │ └── player_fx.h │ └── sn │ │ ├── cmpdi2.c │ │ ├── divdi3.c │ │ ├── fixunssfdi.c │ │ ├── floatdidf.c │ │ ├── floatdisf.c │ │ ├── udivdi3.c │ │ └── udivmoddi4.c └── rocket │ ├── codeseg0 │ └── codeseg0.c │ └── codeseg2 │ ├── codeseg2.h │ ├── codeseg2_0.c │ ├── codeseg2_1.c │ ├── codeseg2_103.c │ ├── codeseg2_104.c │ ├── codeseg2_105.c │ ├── codeseg2_106.c │ ├── codeseg2_107.c │ ├── codeseg2_108.c │ ├── codeseg2_109.c │ ├── codeseg2_110.c │ ├── codeseg2_111.c │ ├── codeseg2_114.c │ ├── codeseg2_115.c │ ├── codeseg2_116.c │ ├── codeseg2_117.c │ ├── codeseg2_118.c │ ├── codeseg2_119.c │ ├── codeseg2_121.c │ ├── codeseg2_122.c │ ├── codeseg2_123.c │ ├── codeseg2_124.c │ ├── codeseg2_125.c │ ├── codeseg2_126.c │ ├── codeseg2_127.c │ ├── codeseg2_128.c │ ├── codeseg2_129.c │ ├── codeseg2_130.c │ ├── codeseg2_131.c │ ├── codeseg2_132.c │ ├── codeseg2_133.c │ ├── codeseg2_137.c │ ├── codeseg2_138.c │ ├── codeseg2_140.c │ ├── codeseg2_144.c │ ├── codeseg2_145.c │ ├── codeseg2_146.c │ ├── codeseg2_147.c │ ├── codeseg2_148.c │ ├── codeseg2_149.c │ ├── codeseg2_150.c │ ├── codeseg2_151.c │ ├── codeseg2_152.c │ ├── codeseg2_153.c │ ├── codeseg2_154.c │ ├── codeseg2_157.c │ ├── codeseg2_158.c │ ├── codeseg2_16.c │ ├── codeseg2_160.c │ ├── codeseg2_163.c │ ├── codeseg2_164.c │ ├── codeseg2_167.c │ ├── codeseg2_169.c │ ├── codeseg2_17.c │ ├── codeseg2_171.c │ ├── codeseg2_172.c │ ├── codeseg2_173.c │ ├── codeseg2_174.c │ ├── codeseg2_175.c │ ├── codeseg2_176.c │ ├── codeseg2_178.c │ ├── codeseg2_179.c │ ├── codeseg2_18.c │ ├── codeseg2_180.c │ ├── codeseg2_181.c │ ├── codeseg2_182.c │ ├── codeseg2_183.c │ ├── codeseg2_184.c │ ├── codeseg2_185.c │ ├── codeseg2_188.c │ ├── codeseg2_189.c │ ├── codeseg2_19.c │ ├── codeseg2_190.c │ ├── codeseg2_191.c │ ├── codeseg2_192.c │ ├── codeseg2_196.c │ ├── codeseg2_197.c │ ├── codeseg2_198.c │ ├── codeseg2_2.c │ ├── codeseg2_20.c │ ├── codeseg2_203.c │ ├── codeseg2_204.c │ ├── codeseg2_207.c │ ├── codeseg2_209.c │ ├── codeseg2_21.c │ ├── codeseg2_210.c │ ├── codeseg2_214.c │ ├── codeseg2_219.c │ ├── codeseg2_22.c │ ├── codeseg2_221.c │ ├── codeseg2_222.c │ ├── codeseg2_223.c │ ├── codeseg2_224.c │ ├── codeseg2_225.c │ ├── codeseg2_226.c │ ├── codeseg2_227.c │ ├── codeseg2_228.c │ ├── codeseg2_23.c │ ├── codeseg2_230.c │ ├── codeseg2_231.c │ ├── codeseg2_232.c │ ├── codeseg2_233.c │ ├── codeseg2_240.c │ ├── codeseg2_243.c │ ├── codeseg2_244.c │ ├── codeseg2_245.c │ ├── codeseg2_247.c │ ├── codeseg2_248.c │ ├── codeseg2_249.c │ ├── codeseg2_261.c │ ├── codeseg2_262.c │ ├── codeseg2_263.c │ ├── codeseg2_266.c │ ├── codeseg2_267.c │ ├── codeseg2_269.c │ ├── codeseg2_27.c │ ├── codeseg2_270.c │ ├── codeseg2_272.c │ ├── codeseg2_273.c │ ├── codeseg2_274.c │ ├── codeseg2_276.c │ ├── codeseg2_277.c │ ├── codeseg2_278.c │ ├── codeseg2_279.c │ ├── codeseg2_28.c │ ├── codeseg2_281.c │ ├── codeseg2_282.c │ ├── codeseg2_283.c │ ├── codeseg2_285.c │ ├── codeseg2_29.c │ ├── codeseg2_293.c │ ├── codeseg2_296.c │ ├── codeseg2_298.c │ ├── codeseg2_299.c │ ├── codeseg2_3.c │ ├── codeseg2_30.c │ ├── codeseg2_300.c │ ├── codeseg2_301.c │ ├── codeseg2_302.c │ ├── codeseg2_303.c │ ├── codeseg2_304.c │ ├── codeseg2_308.c │ ├── codeseg2_31.c │ ├── codeseg2_311.c │ ├── codeseg2_312.c │ ├── codeseg2_317.c │ ├── codeseg2_32.c │ ├── codeseg2_320.c │ ├── codeseg2_321.c │ ├── codeseg2_322.c │ ├── codeseg2_324.c │ ├── codeseg2_325.c │ ├── codeseg2_326.c │ ├── codeseg2_327.c │ ├── codeseg2_33.c │ ├── codeseg2_330.c │ ├── codeseg2_331.c │ ├── codeseg2_332.c │ ├── codeseg2_333.c │ ├── codeseg2_334.c │ ├── codeseg2_335.c │ ├── codeseg2_34.c │ ├── codeseg2_341.c │ ├── codeseg2_343.c │ ├── codeseg2_346.c │ ├── codeseg2_35.c │ ├── codeseg2_351.c │ ├── codeseg2_352.c │ ├── codeseg2_36.c │ ├── codeseg2_365.c │ ├── codeseg2_366.c │ ├── codeseg2_367.c │ ├── codeseg2_368.c │ ├── codeseg2_369.c │ ├── codeseg2_37.c │ ├── codeseg2_370.c │ ├── codeseg2_371.c │ ├── codeseg2_372.c │ ├── codeseg2_373.c │ ├── codeseg2_375.c │ ├── codeseg2_376.c │ ├── codeseg2_377.c │ ├── codeseg2_378.c │ ├── codeseg2_38.c │ ├── codeseg2_380.c │ ├── codeseg2_382.c │ ├── codeseg2_383.c │ ├── codeseg2_384.c │ ├── codeseg2_385.c │ ├── codeseg2_386.c │ ├── codeseg2_387.c │ ├── codeseg2_388.c │ ├── codeseg2_389.c │ ├── codeseg2_390.c │ ├── codeseg2_391.c │ ├── codeseg2_392.c │ ├── codeseg2_393.c │ ├── codeseg2_394.c │ ├── codeseg2_395.c │ ├── codeseg2_396.c │ ├── codeseg2_40.c │ ├── codeseg2_404.c │ ├── codeseg2_405.c │ ├── codeseg2_406.c │ ├── codeseg2_407.c │ ├── codeseg2_408.c │ ├── codeseg2_41.c │ ├── codeseg2_410.c │ ├── codeseg2_411.c │ ├── codeseg2_412.c │ ├── codeseg2_413.c │ ├── codeseg2_414.c │ ├── codeseg2_415.c │ ├── codeseg2_416.c │ ├── codeseg2_417.c │ ├── codeseg2_42.c │ ├── codeseg2_420.c │ ├── codeseg2_421.c │ ├── codeseg2_422.c │ ├── codeseg2_423.c │ ├── codeseg2_424.c │ ├── codeseg2_426.c │ ├── codeseg2_427.c │ ├── codeseg2_428.c │ ├── codeseg2_429.c │ ├── codeseg2_430.c │ ├── codeseg2_432.c │ ├── codeseg2_433.c │ ├── codeseg2_434.c │ ├── codeseg2_435.c │ ├── codeseg2_436.c │ ├── codeseg2_437.c │ ├── codeseg2_438.c │ ├── codeseg2_439.c │ ├── codeseg2_44.c │ ├── codeseg2_442.c │ ├── codeseg2_443.c │ ├── codeseg2_446.c │ ├── codeseg2_447.c │ ├── codeseg2_448.c │ ├── codeseg2_449.c │ ├── codeseg2_451.c │ ├── codeseg2_452.c │ ├── codeseg2_46.c │ ├── codeseg2_53.c │ ├── codeseg2_56.c │ ├── codeseg2_61.c │ ├── codeseg2_62.c │ ├── codeseg2_63.c │ ├── codeseg2_66.c │ ├── codeseg2_67.c │ ├── codeseg2_68.c │ ├── codeseg2_69.c │ ├── codeseg2_70.c │ ├── codeseg2_71.c │ ├── codeseg2_75.c │ ├── codeseg2_76.c │ ├── codeseg2_78.c │ ├── codeseg2_79.c │ ├── codeseg2_80.c │ ├── codeseg2_81.c │ ├── codeseg2_82.c │ ├── codeseg2_88.c │ ├── codeseg2_89.c │ ├── codeseg2_90.c │ ├── codeseg2_92.c │ ├── codeseg2_93.c │ ├── codeseg2_94.c │ └── codeseg2_96.c └── tools ├── Makefile ├── NSUE.00.yaml ├── armips.cpp ├── iplfontutil.c ├── m2ctx.py ├── n64cksum.py ├── n64graphics.c ├── n64graphics.h ├── psyq-obj-parser ├── regnum_to_names.py ├── reloc_addrs.txt ├── rename_function.sh ├── rocket-tools ├── .gitignore ├── Makefile ├── archive.cpp ├── bswap.h ├── cgltf.h ├── cgltf_write.h ├── compress_tester.c ├── decompress_bytes.c ├── decompress_tester.c ├── extract_all.py ├── extract_mesh.c ├── extract_texture.c ├── librocket.c └── librocket.h ├── stb ├── stb_image.h └── stb_image_write.h ├── symbol_addrs.txt ├── undefined_syms.txt ├── utils.c └── utils.h /.gitignore: -------------------------------------------------------------------------------- 1 | baserom.us.z64 2 | bin/ 3 | .splat_cache 4 | asm/ 5 | tools/armips 6 | tools/iplfontutil 7 | .vscode 8 | build 9 | match_tmp 10 | __pycache__ 11 | tools/undefined_syms_auto.txt 12 | tools/undefined_funcs_auto.txt 13 | working/ 14 | nonmatchings/ 15 | graphviz_render* 16 | ctx.c 17 | out.s 18 | tools/gcc-2.7.2 19 | tools/modern-sn64 20 | *.d 21 | NSUE.ld 22 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "tools/splat"] 2 | path = tools/splat 3 | url = https://github.com/ethteck/splat.git 4 | [submodule "f3dex2"] 5 | path = f3dex2 6 | url = https://github.com/Mr-Wiseguy/f3dex2.git 7 | [submodule "ultra"] 8 | path = ultra 9 | url = https://github.com/RocketRet/libreultra.git 10 | [submodule "kmc"] 11 | path = tools/kmc 12 | url = https://github.com/Mr-Wiseguy/kmc-gcc-wrapper.git 13 | [submodule "tools/rocket-tools/lib/fmtlib"] 14 | path = tools/rocket-tools/lib/fmtlib 15 | url = https://github.com/fmtlib/fmt.git 16 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Rocket-Robot-On-Wheels 2 | Decompilation of the N64 game "Rocket: Robot on Wheels" 3 | 4 | To build, install mips gcc and mips binutils as seen on other decomp projects, place an umodified "Rocket: Robot on Wheels" ROM in the root directory of this project with the filename `baserom.us.z64` and run make setup once, followed by make to build. 5 | -------------------------------------------------------------------------------- /diff: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | python3 ./diff.py -wm3 $1 4 | 5 | 6 | -------------------------------------------------------------------------------- /diff_settings.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | def add_custom_arguments(parser): 4 | group = parser.add_mutually_exclusive_group(required=False) 5 | group.add_argument('-u', dest='lang', action='store_const', const='us', 6 | help="Set version to US.") 7 | 8 | def apply(config, args): 9 | lang = args.lang or 'us' 10 | config['mapfile'] = f'build/{lang}/NSUE.map' 11 | config['myimg'] = f'build/{lang}/NSUE.z64' 12 | config['baseimg'] = f'baserom.us.z64' 13 | config['makeflags'] = [f'VERSION={lang}'] 14 | config['source_directories'] = ['src', 'include'] 15 | -------------------------------------------------------------------------------- /include/2.0I/PR/rmon.h: -------------------------------------------------------------------------------- 1 | /************************************************************************** 2 | * * 3 | * Copyright (C) 1995, Silicon Graphics, Inc. * 4 | * * 5 | * These coded instructions, statements, and computer programs contain * 6 | * unpublished proprietary information of Silicon Graphics, Inc., and * 7 | * are protected by Federal copyright law. They may not be disclosed * 8 | * to third parties or copied or duplicated in any form, in whole or * 9 | * in part, without the prior written consent of Silicon Graphics, Inc. * 10 | * * 11 | **************************************************************************/ 12 | 13 | /************************************************************************** 14 | * 15 | * $Revision: 1.6 $ 16 | * $Date: 1997/02/11 08:30:08 $ 17 | * $Source: /hosts/liberte/disk6/Master/cvsmdev2/PR/include/rmon.h,v $ 18 | * 19 | **************************************************************************/ 20 | 21 | #ifndef _RMON_H_ 22 | #define _RMON_H_ 23 | 24 | #ifdef _LANGUAGE_C_PLUS_PLUS 25 | extern "C" { 26 | #endif 27 | 28 | #include 29 | #define RMON_DBG_BUF_SIZE 2048 30 | #define RMON_STACKSIZE 0x1000 31 | 32 | extern void rmonMain( void * ); 33 | extern void rmonPrintf( const char *, ... ); 34 | 35 | #ifdef _LANGUAGE_C_PLUS_PLUS 36 | } 37 | #endif 38 | 39 | #endif /* !_OS_H */ 40 | -------------------------------------------------------------------------------- /include/2.0I/assert.h: -------------------------------------------------------------------------------- 1 | #ifndef __ASSERT_H__ 2 | #define __ASSERT_H__ 3 | 4 | extern void __assert(const char *, const char *, int); 5 | #define assert(EX) ((EX)?((void)0):__assert("EX", __FILE__, __LINE__)) 6 | #define assert_filename(EX, filename) ((EX)?((void)0):__assert("EX", filename, __LINE__)) 7 | 8 | #endif /* !__ASSERT_H__ */ 9 | -------------------------------------------------------------------------------- /include/2.0I/bstring.h: -------------------------------------------------------------------------------- 1 | #ifndef __BSTRING_H__ 2 | #define __BSTRING_H__ 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | /* 8 | * bstring(3C) -- byte string operations 9 | * 10 | * Copyright 1990, Silicon Graphics, Inc. 11 | * All Rights Reserved. 12 | * 13 | * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.; 14 | * the contents of this file may not be disclosed to third parties, copied or 15 | * duplicated in any form, in whole or in part, without the prior written 16 | * permission of Silicon Graphics, Inc. 17 | * 18 | * RESTRICTED RIGHTS LEGEND: 19 | * Use, duplication or disclosure by the Government is subject to restrictions 20 | * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data 21 | * and Computer Software clause at DFARS 252.227-7013, and/or in similar or 22 | * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished - 23 | * rights reserved under the Copyright Laws of the United States. 24 | */ 25 | 26 | #ident "$Revision: 1.4 $" 27 | 28 | extern void bcopy(const void *, void *, int); 29 | extern int bcmp(const void *, const void *, int); 30 | extern void bzero(void *, int); 31 | extern void blkclr(void *, int); 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | #endif /* !__BSTRING_H__ */ 37 | -------------------------------------------------------------------------------- /include/2.0I/ultra64.h: -------------------------------------------------------------------------------- 1 | 2 | /************************************************************************** 3 | * * 4 | * Copyright (C) 1994, Silicon Graphics, Inc. * 5 | * * 6 | * These coded instructions, statements, and computer programs contain * 7 | * unpublished proprietary information of Silicon Graphics, Inc., and * 8 | * are protected by Federal copyright law. They may not be disclosed * 9 | * to third parties or copied or duplicated in any form, in whole or * 10 | * in part, without the prior written consent of Silicon Graphics, Inc. * 11 | * * 12 | *************************************************************************/ 13 | 14 | /************************************************************************** 15 | * 16 | * $Revision: 1.10 $ 17 | * $Date: 1997/02/11 08:37:33 $ 18 | * $Source: /hosts/liberte/disk6/Master/cvsmdev2/PR/include/ultra64.h,v $ 19 | * 20 | **************************************************************************/ 21 | 22 | #ifndef _ULTRA64_H_ 23 | #define _ULTRA64_H_ 24 | 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | // #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /include/audio.h: -------------------------------------------------------------------------------- 1 | #ifndef __AUDIO_H__ 2 | #define __AUDIO_H__ 3 | 4 | #include 5 | 6 | #define AUDIO_HEAP_SIZE 0x39800 7 | #define AUDIO_SAMPLE_RATE 22500 8 | 9 | extern void *gAudioHeapPtr; 10 | 11 | extern u8 gAudioFxBank[]; 12 | extern u8 gAudioPtrBank[]; 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /include/audio_syms.h: -------------------------------------------------------------------------------- 1 | #ifndef __AUDIO_SYMS_H__ 2 | #define __AUDIO_SYMS_H__ 3 | 4 | #include 5 | 6 | extern u8 fxbank_ROM_START[]; 7 | extern u8 ptrbank_ROM_START[]; 8 | extern u8 song00_ROM_START[]; 9 | extern u8 song01_ROM_START[]; 10 | extern u8 song02_ROM_START[]; 11 | extern u8 song03_ROM_START[]; 12 | extern u8 song04_ROM_START[]; 13 | extern u8 song05_ROM_START[]; 14 | extern u8 song06_ROM_START[]; 15 | extern u8 song07_ROM_START[]; 16 | extern u8 song08_ROM_START[]; 17 | extern u8 song09_ROM_START[]; 18 | extern u8 song0A_ROM_START[]; 19 | extern u8 song0B_ROM_START[]; 20 | extern u8 song0C_ROM_START[]; 21 | extern u8 song0D_ROM_START[]; 22 | extern u8 song0E_ROM_START[]; 23 | extern u8 song0F_ROM_START[]; 24 | extern u8 song10_ROM_START[]; 25 | extern u8 song11_ROM_START[]; 26 | extern u8 song12_ROM_START[]; 27 | extern u8 song13_ROM_START[]; 28 | extern u8 song14_ROM_START[]; 29 | extern u8 song15_ROM_START[]; 30 | extern u8 song16_ROM_START[]; 31 | 32 | extern u8 fxbank_ROM_END[]; 33 | extern u8 ptrbank_ROM_END[]; 34 | extern u8 song00_ROM_END[]; 35 | extern u8 song01_ROM_END[]; 36 | extern u8 song02_ROM_END[]; 37 | extern u8 song03_ROM_END[]; 38 | extern u8 song04_ROM_END[]; 39 | extern u8 song05_ROM_END[]; 40 | extern u8 song06_ROM_END[]; 41 | extern u8 song07_ROM_END[]; 42 | extern u8 song08_ROM_END[]; 43 | extern u8 song09_ROM_END[]; 44 | extern u8 song0A_ROM_END[]; 45 | extern u8 song0B_ROM_END[]; 46 | extern u8 song0C_ROM_END[]; 47 | extern u8 song0D_ROM_END[]; 48 | extern u8 song0E_ROM_END[]; 49 | extern u8 song0F_ROM_END[]; 50 | extern u8 song10_ROM_END[]; 51 | extern u8 song11_ROM_END[]; 52 | extern u8 song12_ROM_END[]; 53 | extern u8 song13_ROM_END[]; 54 | extern u8 song14_ROM_END[]; 55 | extern u8 song15_ROM_END[]; 56 | extern u8 song16_ROM_END[]; 57 | 58 | #endif 59 | -------------------------------------------------------------------------------- /include/bss.h: -------------------------------------------------------------------------------- 1 | #define BSS_VAL __attribute__((section(".bss"))) = 0 2 | #define BSS __attribute__((section(".bss"))) = {0} 3 | -------------------------------------------------------------------------------- /include/gameplay.h: -------------------------------------------------------------------------------- 1 | #ifndef __GAMEPLAY_H__ 2 | #define __GAMEPLAY_H__ 3 | 4 | #include "mus/libmus.h" 5 | 6 | #define LEVEL_TOKEN_COUNT 200 7 | 8 | musHandle play_sound(u32 number, s32 arg1, s32 volume, s32 pan); 9 | 10 | #endif 11 | -------------------------------------------------------------------------------- /include/gfx.h: -------------------------------------------------------------------------------- 1 | #ifndef __GFX_H__ 2 | #define __GFX_H__ 3 | 4 | #include "types.h" 5 | #include "materials.h" 6 | 7 | #define NEXT_GFX(gfx) (++gfx - 1) 8 | 9 | #define SCREEN_WIDTH 320 10 | #define SCREEN_HEIGHT 240 11 | #define MARGIN_X 18 12 | #define MARGIN_Y 14 13 | #define FRAMEBUFFER_BYTES ((SCREEN_WIDTH) * (SCREEN_HEIGHT) * sizeof(u16)) 14 | 15 | struct unkD_8009F094_inner { 16 | u8 pad[0xC4]; 17 | Lights1 *light; 18 | u8 pad2[0x128 - 0xC8]; 19 | s32 unk128[1]; 20 | }; 21 | 22 | struct unkD_8009F094 { 23 | struct unkD_8009F094_inner *unk0; 24 | }; 25 | 26 | extern struct unkD_8009F094 D_8009F094; 27 | 28 | extern RGBA32 D_800A5398; 29 | extern RGBA32 D_800A539C; 30 | 31 | extern struct { 32 | s32 unk0; 33 | f32 unk4; 34 | } D_8009FE10; 35 | 36 | void draw_rectangle(s32, s32, s32, s32, s32, s32, s32, s32); 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /include/include_asm.h: -------------------------------------------------------------------------------- 1 | #ifndef __INCLUDE_ASM_H__ 2 | #define __INCLUDE_ASM_H__ 3 | 4 | #define NONMATCHING_SUFFIX "_NONMATCHING" 5 | 6 | #if !defined(SPLAT) && !defined(__CTX__) && !defined(KMC) && !defined(PERMUTER) 7 | #ifndef INCLUDE_ASM 8 | #define INCLUDE_ASM(TYPE, FOLDER, NAME, ARGS...) \ 9 | TYPE NAME(ARGS);\ 10 | \ 11 | asm ( \ 12 | "\t.text\n" \ 13 | "\t.set noat\n" \ 14 | "\t.set noreorder\n" \ 15 | "\t.global " #NAME NONMATCHING_SUFFIX "\n" \ 16 | "\t.equiv " #NAME NONMATCHING_SUFFIX ", 0\n" \ 17 | "\t.ent " #NAME "\n" \ 18 | "\t.type " #NAME ", @function\n" \ 19 | "\t.include \"asm/nonmatchings/"FOLDER"/"#NAME".s\"\n" \ 20 | "\t.end " #NAME "\n" \ 21 | "\t.set reorder\n" \ 22 | "\t.set at\n" \ 23 | ); 24 | #endif 25 | // __asm__( ".include \"include/macro.inc\"\n"); 26 | #else 27 | #define INCLUDE_ASM(TYPE, FOLDER, NAME, ARGS...) 28 | #endif 29 | 30 | #endif -------------------------------------------------------------------------------- /include/macro.inc: -------------------------------------------------------------------------------- 1 | # Assembly Macros 2 | 3 | .set gp=64 4 | 5 | .set K0BASE, 0x80000000 6 | .set K1BASE, 0xA0000000 7 | .set K2BASE, 0xC0000000 8 | 9 | .macro glabel label 10 | .global \label 11 | .type \label, @function 12 | \label: 13 | .endm 14 | 15 | .macro dlabel label 16 | .global \label 17 | \label: 18 | .endm 19 | 20 | .macro .word32 x 21 | .word \x 22 | .endm 23 | 24 | .macro move a, b 25 | addu \a, \b, $zero 26 | .endm 27 | -------------------------------------------------------------------------------- /include/macros.h: -------------------------------------------------------------------------------- 1 | #ifndef __MACROS_H__ 2 | #define __MACROS_H__ 3 | 4 | #ifdef __GNUC__ 5 | #define ALIGNED(x) __attribute__((aligned(x))) 6 | #define UNUSED __attribute__((unused)) 7 | #else 8 | #define ALIGNED(x) 9 | #define UNUSED 10 | #endif 11 | 12 | #ifndef FLT_MAX 13 | #define FLT_MAX 3.4028235e38f 14 | #endif 15 | 16 | #ifndef INT_MAX 17 | #define INT_MAX 0x7FFFFFFF 18 | #endif 19 | 20 | #define ROMADDR(x) ((u32)x + 0xB0000000) 21 | 22 | #define RAM_END 0x80400000 23 | 24 | #define SQUARED(x) \ 25 | ((x) * (x)) 26 | 27 | #define VEC3F_COPY(dst, src) \ 28 | __builtin_memcpy(dst, src, 3 * sizeof(f32)) 29 | 30 | #define VEC3F_ADD(dst, a, b) \ 31 | (dst)[0] = (a)[0] + (b)[0]; \ 32 | (dst)[1] = (a)[1] + (b)[1]; \ 33 | (dst)[2] = (a)[2] + (b)[2] 34 | 35 | #define VEC3F_SUB(dst, a, b) \ 36 | (dst)[0] = (a)[0] - (b)[0]; \ 37 | (dst)[1] = (a)[1] - (b)[1]; \ 38 | (dst)[2] = (a)[2] - (b)[2] 39 | 40 | #define VEC3F_DOT(a, b) \ 41 | ((a)[0] * (b)[0] + (a)[1] * (b)[1] + (a)[2] * (b)[2]) 42 | 43 | #define MTX3F_COPY(dst, src) \ 44 | __builtin_memcpy(dst, src, 9 * sizeof(f32)) 45 | 46 | #define VEC3F_MAG_SQUARED(x) \ 47 | ((x)[0] * (x)[0] + (x)[1] * (x)[1] + (x)[2] * (x)[2]) 48 | 49 | #define sqrtf __inline_sqrtf 50 | #define sqrt __inline_sqrt 51 | 52 | static __inline__ __const__ f32 __inline_sqrtf (f32 in) 53 | { 54 | float out; 55 | __asm__("sqrt.s %0,%1" : "=f" (out) : "f" (in)); 56 | return out; 57 | } 58 | 59 | static __inline__ __const__ f64 __inline_sqrt (f64 in) 60 | { 61 | float out; 62 | __asm__("sqrt.d %0,%1" : "=f" (out) : "f" (in)); 63 | return out; 64 | } 65 | 66 | #define fabsf __inline_absf 67 | 68 | static __inline__ __const__ f32 __inline_absf (f32 in) 69 | { 70 | float out; 71 | __asm__("abs.s %0,%1" : "=f" (out) : "f" (in)); 72 | return out; 73 | } 74 | 75 | #endif -------------------------------------------------------------------------------- /include/materials.h: -------------------------------------------------------------------------------- 1 | #ifndef __MATERIALS_H__ 2 | #define __MATERIALS_H__ 3 | 4 | #include "types.h" 5 | #include "mem.h" 6 | 7 | #define MATERIAL_FLAG_TWO_SIDED 0x01 8 | #define MATERIAL_FLAG_POINT_FILTERED 0x02 9 | #define MATERIAL_FLAG_MIPMAPPED 0x40 10 | #define MATERIAL_FLAG_MULTITEXTURE_MIX 0x80 11 | 12 | #define gDPSetCombineLERP_custom(pkt, a0, b0, c0, d0, Aa0, Ab0, Ac0, Ad0, \ 13 | a1, b1, c1, d1, Aa1, Ab1, Ac1, Ad1) \ 14 | { \ 15 | Gfx *_g = (Gfx *)(pkt); \ 16 | \ 17 | _g->words.w0 = _SHIFTL(G_SETCOMBINE, 24, 8) | \ 18 | _SHIFTL(GCCc0w0(a0, c0, \ 19 | Aa0, Ac0) | \ 20 | GCCc1w0(a1, c1), \ 21 | 0, 24); \ 22 | _g->words.w1 = (unsigned int)(GCCc0w1(b0, \ 23 | d0, \ 24 | Ab0, \ 25 | Ad0) | \ 26 | GCCc1w1(b1, \ 27 | Aa1, \ 28 | Ac1, \ 29 | d1, \ 30 | Ab1, \ 31 | Ad1)); \ 32 | } 33 | 34 | struct unkfunc_800926B8 { 35 | s32 pad0; 36 | s32 pad4; 37 | Gfx *unk8; 38 | }; 39 | 40 | typedef struct CombinerParams_s { 41 | u8 color[4]; 42 | u8 alpha[4]; 43 | } CombinerParams; 44 | 45 | typedef union RGBA32_u { 46 | struct { 47 | u8 r; 48 | u8 g; 49 | u8 b; 50 | u8 a; 51 | } colors; 52 | u8 asArray[4]; 53 | u32 rgba32; 54 | } RGBA32; 55 | 56 | typedef union RGBA32_pad8_u { 57 | struct { 58 | u8 r; 59 | u8 g; 60 | u8 b; 61 | u8 a; 62 | } colors; 63 | u32 rgba32; 64 | u8 asArray[4]; 65 | u8 pad[8]; 66 | } RGBA32_pad8; 67 | 68 | static inline struct TexturedMaterial *get_material_data(struct MaterialGfx *materialGfx) { 69 | struct TexturedMaterial *ret; 70 | if (IS_K0_ADDRESS(materialGfx->materialData.raw)) { 71 | ret = materialGfx->materialData.texturedMaterial; 72 | } else { 73 | ret = load_textured_material(materialGfx); 74 | } 75 | return ret; 76 | } 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /include/mathutils.h: -------------------------------------------------------------------------------- 1 | #ifndef __MATHUTILS_H__ 2 | #define __MATHUTILS_H__ 3 | 4 | #include "types.h" 5 | 6 | float vec2f_magnitude(Vec2f in); 7 | 8 | void set_vec3f_components(Vec3f vec, f32 x, f32 y, f32 z); 9 | void vec3f_rotate(Mtx3f mat, Vec3f in, Vec3f out); 10 | void vec3f_transform(Mtx4f mat, Vec3f in, f32 w, Vec3f out); 11 | float vec3f_safe_normalize(Vec3f in, Vec3f out); 12 | float vec3f_dist(Vec3f a, Vec3f b); 13 | float vec3f_xy_dist(Vec3f a, Vec3f b); 14 | float vec3f_dist_sq(Vec3f a, Vec3f b); 15 | void vec3f_scale(float scale, Vec3f in, Vec3f out); 16 | void vec3f_cross_product(Vec3f a, Vec3f b, Vec3f out); 17 | void vec3f_scale_add(float aScale, Vec3f a, float bScale, Vec3f b, Vec3f out); 18 | void vec3f_lerp(float t, Vec3f a, Vec3f b, Vec3f out); 19 | f32 vec3f_normalize(Vec3f vec); 20 | void vec3f_transpose_rotate(Mtx3f mat, Vec3f in, Vec3f out); 21 | 22 | void mtx3f_concat(Mtx3f a, Mtx3f b, Mtx3f out); 23 | void mtx3f_transpose(Mtx3f in, Mtx3f out); 24 | void mtx3f_rotate_axis(f32 angle, Vec3f arg1, Mtx3f out); 25 | void mtx3f_axis_angle(Vec3f in, Mtx3f out); 26 | 27 | void sincosf(float angle, float* sinout, float* cosout); 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /include/mem.h: -------------------------------------------------------------------------------- 1 | #ifndef __MEM_H__ 2 | #define __MEM_H__ 3 | 4 | #include 5 | #include 6 | 7 | #define IS_SOLID_COLOR(x) \ 8 | ((((u32)(x)) & 0xF0000000) == 0x00000000) 9 | 10 | #define IS_K0_ADDRESS(x) \ 11 | ((((u32)(x)) & 0xF0000000) == 0x80000000) 12 | 13 | // Segment table 14 | extern u32 D_800AAF78[]; 15 | 16 | #define SEGMENTED_TO_VIRTUAL(addr) (void*)(D_800AAF78[(((u32)(addr)) >> 24) & 0xF] + (((u32)(addr)) & 0xFFFFFF)) 17 | 18 | #define READ_VALUE(x, type) ({*x += sizeof(type); *(type*)(*x - sizeof(type));}) 19 | static inline u32 read_u32(u8 **ptr) { *ptr += sizeof(u32); return *(u32*)(*ptr - sizeof(u32)); } 20 | static inline u16 read_u16(u8 **ptr) { *ptr += sizeof(u16); return *(u16*)(*ptr - sizeof(u16)); } 21 | static inline f32 read_f32(u8 **ptr) { *ptr += sizeof(f32); return *(f32*)(*ptr - sizeof(f32)); } 22 | void read_vec3f(u8 **ptr, Vec3f out); 23 | 24 | #define ALIGN_PTR(s, align) (void *)(((u32)(s) + ((align)-1)) & ~((align)-1)) 25 | 26 | extern struct Texture **textureTable; 27 | extern s32 textureTableAddress; 28 | extern s32 textureTableLength; 29 | 30 | extern u8 _assetsSegmentRomStart[]; 31 | extern void (*textureHandlers[])(s32, struct TextureCompressionHeader*, struct Texture*); 32 | extern struct DecompressionParams compressionParamsTable[2]; 33 | 34 | void *main_alloc_copy(s32 size, u8 *src); 35 | void *main_alloc_bzero(u32 len); 36 | void *main_alloc_nozero(u32 len); 37 | void dma_read(u32 romAddr, void *ramAddr, u32 len); 38 | void *alloc_second_heap(u32 len); 39 | void decompress(struct DecompressionParams *arg0, u32 compressedSize, u8 *src, u32 uncompressedSize, u8 *dst); 40 | void push_second_heap_state(); 41 | void pop_second_heap_state(); 42 | 43 | struct Texture *load_texture(uintptr_t *textureRomAddress); 44 | struct TexturedMaterial *load_textured_material(struct MaterialGfx *arg0); 45 | 46 | #endif 47 | -------------------------------------------------------------------------------- /include/mus/libmus_config.h: -------------------------------------------------------------------------------- 1 | 2 | /********************************************************* 3 | 4 | libmus_config.h : Nintendo 64 Music Tools Programmers Library 5 | (c) Copyright 1997/1998, Software Creations (Holdings) Ltd. 6 | 7 | Version 3.14 8 | 9 | Configuration file for libary compilation this should be 10 | included first and be the main dependancy for library 11 | source files. This file should also contain information 12 | relating to specific library extensions and current 13 | development work. 14 | 15 | This file should now only be changed during development, 16 | all configurable flags have been moved to the makefile. 17 | 18 | **********************************************************/ 19 | 20 | #ifndef _LIBMUS_CONFIG_H_ 21 | #define _LIBMUS_CONFIG_H_ 22 | 23 | /* 24 | Audio configuration settings moved to makefile: 25 | 26 | _AUDIODEBUG 27 | Includes limited validation code into the library. Reports 28 | various types of incorrect data or parameters via the 29 | osSyncPrintf() function. 30 | 31 | SUPPORT_NAUDIO 32 | Configure library to use the "n_audio" library and microcode 33 | included with the Nintendo LIB2.0i library release. 34 | 35 | */ 36 | 37 | 38 | #define SUPPORT_FXCHANGE 39 | /* 40 | Development code to support the changing of the audio FX 41 | bus currently being used. 42 | This setting should be set by default. 43 | */ 44 | 45 | 46 | 47 | /* NOTE: 48 | 49 | The following defines control various functions that may 50 | be included in future versions of the library. These flags 51 | should not be used in a standard version of the library. 52 | */ 53 | 54 | /*#define SUPPORT_PROFILER*/ 55 | /* 56 | This enables CPU performance monitoring for the main driver 57 | code. The variables "_mus_cpu_last" and "_mus_cpu_worst" 58 | become available as externals. These variables are calculated 59 | using the osGetCount() function. 60 | */ 61 | 62 | /*#define SUPPORT_EFFECTS*/ 63 | /* 64 | Currently a Software Creations only extension to the library 65 | which allows the programmer to apply specific effects to the 66 | continuous volume and pitch bend data. 67 | This setting should not be used. 68 | */ 69 | 70 | /*#define SUPPORT_WAVEMONITORING*/ 71 | /* 72 | Currently a Software Creations only extension which counts 73 | the number of times a particular sample is used (8-bit only). 74 | */ 75 | 76 | 77 | 78 | 79 | #endif /* _LIBMUS_CONFIG_H_ */ 80 | 81 | /* end of file */ 82 | -------------------------------------------------------------------------------- /include/mus/n_libaudio_sn_sc.h: -------------------------------------------------------------------------------- 1 | #define ALVoice N_ALVoice 2 | #define ALSynth N_ALSynth 3 | #define ALGlobals N_ALGlobals 4 | 5 | #define alSynAddPlayer( a, b) n_alSynAddPlayer( b) 6 | #define alSynAllocFX( a, b, c, d) n_alSynAllocFX( b, c, d) 7 | #define alSynAllocVoice( a, b, c) n_alSynAllocVoice( b, c) 8 | #define alSynDelete( a) n_alSynDelete() 9 | #define alSynFreeVoice( a, b) n_alSynFreeVoice( b) 10 | #define alSynGetFXRef( a, b, c) n_alSynGetFXRef( b, c) 11 | #define alSynGetPriority( a, b) n_alSynGetPriority( b) 12 | #define alSynRemovePlayer( a, b) n_alSynRemovePlayer( b) 13 | #define alSynSetFXMix( a, b, c) n_alSynSetFXMix( b, c) 14 | #define alSynSetFXParam( a, b, c, d) n_alSynSetFXParam( b, c, d) 15 | #define alSynSetFXtype( a, b, c, d) n_alSynSetFXtype( b, c, d) 16 | #define alSynSetPan( a, b, c) n_alSynSetPan( b, c) 17 | #define alSynSetPitch( a, b, c) n_alSynSetPitch( b, c) 18 | #define alSynSetPriority( a, b, c) n_alSynSetPriority( b, c) 19 | #define alSynSetVol( a, b, c, d) n_alSynSetVol( b, c, d) 20 | #define alSynStartVoice( a, b, c) n_alSynStartVoice( b, c) 21 | #define alSynStartVoiceParams( a, b, c, d, e, f, g, h) \ 22 | n_alSynStartVoiceParams( b, c, d, e, f, g, h) 23 | #define alSynStopVoice( a, b) n_alSynStopVoice( b) 24 | #define alSynNew( a, b) n_alSynNew( b) 25 | 26 | #define alInit n_alInit 27 | #define alClose( a ) n_alClose() 28 | #define alAudioFrame n_alAudioFrame 29 | -------------------------------------------------------------------------------- /include/mus/player_fifo.h: -------------------------------------------------------------------------------- 1 | 2 | /********************************************************* 3 | 4 | player_fifo.h : Nintendo 64 Music Tools Programmers Library 5 | (c) Copyright 1997/1998, Software Creations (Holdings) Ltd. 6 | 7 | Version 3.14 8 | 9 | Music library fifo functions (only use internally!). 10 | 11 | **********************************************************/ 12 | 13 | #ifndef _PLAYER_FIFO_H_ 14 | #define _PLAYER_FIFO_H_ 15 | 16 | typedef struct 17 | { 18 | unsigned char command; 19 | unsigned char padding1; 20 | unsigned char padding2; 21 | unsigned char padding3; 22 | unsigned long data; 23 | } fifo_t; 24 | 25 | /* fifo size limits */ 26 | #define MIN_FIFO_COMMANDS (64) 27 | #define MAX_FIFO_COMMANDS (1024) 28 | 29 | /* fifo commands */ 30 | enum 31 | { 32 | FIFOCMD_PAUSE, 33 | FIFOCMD_UNPAUSE, 34 | FIFOCMD_CHANGEFX, 35 | FIFOCMD_LAST 36 | }; 37 | 38 | static void __MusIntFifoOpen(int commands); 39 | static void __MusIntFifoProcess(void); 40 | static void __MusIntFifoProcessCommand(fifo_t *command); 41 | static int __MusIntFifoAddCommand(fifo_t *command); 42 | 43 | 44 | #endif /* _PLAYER_FIFO_H_ */ 45 | 46 | /* end of file */ 47 | -------------------------------------------------------------------------------- /include/sounds.h: -------------------------------------------------------------------------------- 1 | #ifndef __SOUNDS_H__ 2 | #define __SOUNDS_H__ 3 | 4 | typedef enum { 5 | SFX_ROCKET_PICKING_UP = 0x00, 6 | SFX_ROCKET_HOLDING = 0x01, 7 | SFX_ROCKET_LET_GO = 0x02, 8 | 9 | SFX_ROCKET_YIP = 0x04, 10 | SFX_ROCKET_LAND = 0x05, 11 | SFX_ROCKET_OW = 0x06, 12 | SFX_ROCKET_ENTER_VEHICLE = 0x07, 13 | SFX_ROCKET_EXIT_VEHICLE = 0x08, 14 | SFX_ROCKET_YEAH = 0x09, 15 | 16 | SFX_GET_TICKET = 0x0C, 17 | SFX_ROCKET_HOO = 0x0D, 18 | SFX_ROCKET_WHEE = 0x0E, 19 | SFX_ROCKET_WOOHOO = 0x0F, 20 | 21 | SFX_BUZZER = 0x21, 22 | 23 | SFX_PAUSE_CYCLE = 0x23, 24 | SFX_PAUSE_SELECT = 0x24, 25 | SFX_PAUSE_ENTER = 0x25, 26 | SFX_PAUSE_EXIT = 0x26, 27 | SFX_PAUSE_CONTROLS = 0x27, 28 | SFX_PAUSE_HINT = 0x28, 29 | SFX_CAMERA = 0x29, 30 | SFX_CAMERA_STUCK = 0x2A, 31 | 32 | SFX_BEE = 0x2C, 33 | 34 | SFX_GET_TOKEN_SILVER = 0x38, 35 | SFX_GET_TOKEN_GOLD = 0x39, 36 | SFX_GET_TOKEN_PURPLE = 0x3A, 37 | SFX_PAUSE_CYCLE2 = 0x3B, // The same as 0x23? 38 | SFX_PAUSE_SELECT2 = 0x3C, // The same as 0x24? 39 | 40 | SFX_CLOWN_HONK = 0x42, 41 | SFX_CLOWN_LAUGH = 0x43, 42 | SFX_CLOWN_WHISTLE = 0x44, 43 | SFX_CLOWN_OW = 0x45, 44 | 45 | SFX_SHEEP_BAA = 0x4A, 46 | SFX_SHEEP_YELL = 0x4B, 47 | 48 | SFX_ZAP = 0x4E, 49 | 50 | SFX_GAVIN_HMM1 = 0x54, 51 | 52 | SFX_PAINT_SHOOT = 0x56, 53 | SFX_PAINT_SPLAT = 0x57, 54 | SFX_CHICKEN_BUCKAW = 0x58, 55 | 56 | SFX_TROLL = 0x60, 57 | 58 | SFX_MUSHROOM_LAUGH = 0x65, 59 | SFX_MUSHROOM_WAH = 0x66, 60 | 61 | SFX_ZAP2 = 0x68, 62 | 63 | SFX_FREEZE_RAY = 0x6D, 64 | 65 | SFX_GRAPPLE_AIM = 0x6F, 66 | SFX_GRAPPLE_SHOOT = 0x70, 67 | 68 | SFX_PISTON = 0x76, 69 | 70 | SFX_TINKER_HMM = 0x83, 71 | SFX_JOJO_LAUGH1 = 0x84, 72 | SFX_GAVIN_HMM2 = 0x85, 73 | 74 | SFX_WHOOPIE1 = 0x88, 75 | SFX_WHOOPIE2 = 0x89, 76 | SFX_TINKER_WORKING = 0x8A, 77 | 78 | SFX_ROCKET_DEATH = 0x8F, 79 | SFX_ROCKET_HIT1 = 0x90, 80 | SFX_ROCKET_HIT2 = 0x91, 81 | 82 | SFX_CHICKEN_CLUCK = 0x98, 83 | 84 | SFX_JOJO_LAUGH2 = 0x9B, 85 | SFX_GAVIN_HMM3 = 0x9C, 86 | SFX_GAVIN_HMM4 = 0x9D, 87 | SFX_JOJO_SQUEAL = 0x9E, 88 | 89 | SFX_WARP_EXIT = 0xA0, 90 | SFX_WARP_ENTER = 0xA1, 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | } soundId_t; 99 | 100 | #endif 101 | -------------------------------------------------------------------------------- /sn/asn64.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RocketRet/Rocket-Robot-On-Wheels/cd1fc6d3f575841a240373d7b8a2baf532da2f9f/sn/asn64.exe -------------------------------------------------------------------------------- /sn/cc1n64.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RocketRet/Rocket-Robot-On-Wheels/cd1fc6d3f575841a240373d7b8a2baf532da2f9f/sn/cc1n64.exe -------------------------------------------------------------------------------- /sn/ccn64.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RocketRet/Rocket-Robot-On-Wheels/cd1fc6d3f575841a240373d7b8a2baf532da2f9f/sn/ccn64.exe -------------------------------------------------------------------------------- /sn/cppn64.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RocketRet/Rocket-Robot-On-Wheels/cd1fc6d3f575841a240373d7b8a2baf532da2f9f/sn/cppn64.exe -------------------------------------------------------------------------------- /sn/sn.ini: -------------------------------------------------------------------------------- 1 | [ccn64] 2 | compiler_path=.\sn 3 | assembler_path=.\sn 4 | -------------------------------------------------------------------------------- /src/lib/codeseg1/aud_dma.h: -------------------------------------------------------------------------------- 1 | 2 | /********************************************************* 3 | 4 | aud_dma.h : Nintendo 64 Music Tools Programmers Library 5 | (c) Copyright 1997/1998, Software Creations (Holdings) Ltd. 6 | 7 | Version 3.14 8 | 9 | Music library DMA buffer manager. 10 | 11 | **********************************************************/ 12 | 13 | #ifndef _LIBMUS_AUD_DMA_H_ 14 | #define _LIBMUS_AUD_DMA_H_ 15 | 16 | 17 | ALDMANew __MusIntDmaInit (int dma_buffer_count, int dma_buffer_size); 18 | void __MusIntDmaProcess (void); 19 | 20 | 21 | #endif /* _LIBMUS_AUD_DMA_H_ */ 22 | 23 | /* end of file */ 24 | -------------------------------------------------------------------------------- /src/lib/codeseg1/aud_samples.h: -------------------------------------------------------------------------------- 1 | 2 | /********************************************************* 3 | 4 | aud_samples.h : Nintendo 64 Music Tools Programmers Library 5 | (c) Copyright 1997/1998, Software Creations (Holdings) Ltd. 6 | 7 | Version 3.14 8 | 9 | Music library frame sample calculations. 10 | 11 | **********************************************************/ 12 | 13 | #ifndef _LIBMUS_AUD_SAMPLES_H_ 14 | #define _LIBMUS_AUD_SAMPLES_H_ 15 | 16 | 17 | u32 __MusIntSamplesInit (float retrace_count, float output_rate, float vsyncs_per_sec, int extra_rate); 18 | u32 __MusIntSamplesCurrent (); 19 | 20 | 21 | #endif /* _LIBMUS_AUD_SAMPLES_H_ */ 22 | 23 | /* end of file */ 24 | -------------------------------------------------------------------------------- /src/lib/codeseg1/aud_sched.h: -------------------------------------------------------------------------------- 1 | 2 | /********************************************************* 3 | 4 | aud_sched.c : Nintendo 64 Music Tools Programmers Library 5 | (c) Copyright 1997/1998, Software Creations (Holdings) Ltd. 6 | 7 | Version 3.14 8 | 9 | Music library scheduler functions. 10 | 11 | **********************************************************/ 12 | 13 | #ifndef _LIBMUS_AUD_SCHED_H_ 14 | #define _LIBMUS_AUD_SCHED_H_ 15 | 16 | 17 | /* global vars */ 18 | extern musSched *__libmus_current_sched; 19 | 20 | /* function prototypes */ 21 | void __MusIntSchedInit (void *sched); 22 | 23 | /* function prototypes - implemented as macros below */ 24 | void __MusIntSched_install (void); 25 | void __MusIntSched_waitframe (void); 26 | void __MusIntSched_dotask (musTask *task); 27 | 28 | 29 | #define __MusIntSched_install() __libmus_current_sched->install() 30 | #define __MusIntSched_waitframe() __libmus_current_sched->waitframe() 31 | #define __MusIntSched_dotask(task) __libmus_current_sched->dotask((task)) 32 | 33 | 34 | #endif /* _LIBMUS_AUD_SCHED_H_ */ 35 | 36 | /* end of file */ 37 | -------------------------------------------------------------------------------- /src/lib/codeseg1/aud_thread.h: -------------------------------------------------------------------------------- 1 | 2 | /********************************************************* 3 | 4 | aud_thread.h : Nintendo 64 Music Tools Programmers Library 5 | (c) Copyright 1997/1998, Software Creations (Holdings) Ltd. 6 | 7 | Version 3.14 8 | 9 | Music library thread base audio manager. 10 | 11 | **********************************************************/ 12 | 13 | #ifndef _LIBMUS_AUD_THREAD_H_ 14 | #define _LIBMUS_AUD_THREAD_H_ 15 | 16 | 17 | /* global vars */ 18 | extern ALGlobals __libmus_alglobals; 19 | 20 | /* function prototypes */ 21 | void __MusIntAudManInit(musConfig *config, int vsyncs_per_second, int fx_type); 22 | 23 | 24 | #endif /* _LIBMUS_AUD_THREAD_H_ */ 25 | 26 | /* end of file */ 27 | -------------------------------------------------------------------------------- /src/lib/codeseg1/lib_memory.h: -------------------------------------------------------------------------------- 1 | 2 | /********************************************************* 3 | 4 | lib_memory.h : Nintendo 64 Music Tools Programmers Library 5 | (c) Copyright 1997/1998, Software Creations (Holdings) Ltd. 6 | 7 | Version 3.14 8 | 9 | Music library memory manager. 10 | 11 | **********************************************************/ 12 | 13 | #ifndef _LIBMUS_LIB_MEMORY_H_ 14 | #define _LIBMUS_LIB_MEMORY_H_ 15 | 16 | 17 | /* function prototypes */ 18 | void __MusIntMemInit (void *addr, int length); 19 | ALHeap *__MusIntMemGetHeapAddr (void); 20 | void *__MusIntMemMalloc (int length); 21 | int __MusIntMemRemaining (void); 22 | 23 | void __MusIntMemSet (void *dest, unsigned char value, int length); 24 | void __MusIntMemMove (void *dest, void *src, int length); 25 | 26 | 27 | #endif /* _LIBMUS_LIB_MEMORY_H_ */ 28 | 29 | 30 | /* end of file */ 31 | -------------------------------------------------------------------------------- /src/lib/codeseg1/player_fx.h: -------------------------------------------------------------------------------- 1 | 2 | /********************************************************* 3 | 4 | player_fx.h : Nintendo 64 Music Tools Programmers Library 5 | 6 | Version 3.14 7 | 8 | Audio library effect support functions. 9 | 10 | **********************************************************/ 11 | 12 | #ifndef _PLAYER_FX_H_ 13 | #define _PLAYER_FX_H_ 14 | 15 | #include "synthInternals.h" 16 | 17 | 18 | #ifdef SUPPORT_NAUDIO 19 | #include "n_libaudio_sc.h" 20 | #include "n_libaudio_sn_sc.h" 21 | #include "n_synthInternals.h" 22 | #endif 23 | 24 | /* public interface to change effects */ 25 | int ChangeCustomEffect(s32); 26 | 27 | /* internal stuff */ 28 | void CustomInit(ALGlobals *, ALSynConfig *); // replacement for alInit() 29 | 30 | #ifndef SUPPORT_NAUDIO 31 | #define alInit CustomInit 32 | void CustomSynNew(ALSynth *, ALSynConfig *); // replacement for alSynNew() 33 | ALFxRef *CustomAllocFX(ALSynth *, s16, ALSynConfig *, ALHeap *); // replacement for alSynAllocFX() 34 | #else 35 | #define n_alInit CustomInit 36 | void CustomSynNew(ALSynConfig *); // replacement for alSynNew() 37 | ALFxRef CustomAllocFX(s16, ALSynConfig *, ALHeap *); // replacement for alSynAllocFX() 38 | #endif 39 | 40 | /* stuff I've added/altered */ 41 | #ifndef SUPPORT_NAUDIO 42 | void CustomFxNew(ALFx *, ALSynConfig *, ALHeap *); 43 | #else 44 | void CustomFxNew(ALFx **, ALSynConfig *, ALHeap *); 45 | #endif 46 | void CustomFxSet(s32 *); 47 | 48 | 49 | typedef struct 50 | { 51 | /* the synthesizer we;re attached to */ 52 | ALSynth *synth; 53 | 54 | /* effect description */ 55 | int sections; 56 | u32 length; 57 | s32 *pParams; 58 | 59 | /* AlFx object attached to the bus */ 60 | ALDelay *pDelay; 61 | s16 *pBase; 62 | 63 | /* LowPass Filter */ 64 | ALResampler *pResampler; 65 | RESAMPLE_STATE *pResampleState; 66 | ALLowPass *pLowPass; 67 | POLEF_STATE *pLpfState; 68 | 69 | } REVERB_MEM; 70 | 71 | #endif /* _PLAYER_FX_H_ */ 72 | 73 | /*** end of file ***/ 74 | -------------------------------------------------------------------------------- /src/lib/sn/cmpdi2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "lib/sn/cmpdi2", __cmpdi2); 6 | -------------------------------------------------------------------------------- /src/lib/sn/divdi3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "lib/sn/divdi3", __divdi3); 6 | -------------------------------------------------------------------------------- /src/lib/sn/fixunssfdi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "lib/sn/fixunssfdi", __fixunssfdi); 6 | -------------------------------------------------------------------------------- /src/lib/sn/floatdidf.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "lib/sn/floatdidf", __floatdidf); 6 | -------------------------------------------------------------------------------- /src/lib/sn/floatdisf.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "lib/sn/floatdisf", __floatdisf); 6 | -------------------------------------------------------------------------------- /src/lib/sn/udivdi3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | unsigned long long __udivmoddi4(unsigned long long, unsigned long long, unsigned long long *); 5 | 6 | unsigned long long __udivdi3(unsigned long long a, unsigned long long b) 7 | { 8 | return __udivmoddi4(a, b, NULL); 9 | } 10 | -------------------------------------------------------------------------------- /src/lib/sn/udivmoddi4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const u8 D_80000670[] = { 5 | 0x00, 6 | 0x01, 7 | 0x02, 0x02, 8 | 0x03, 0x03, 0x03, 0x03, 9 | 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 10 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 11 | 12 | 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 13 | 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 14 | 15 | 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 16 | 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 17 | 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 18 | 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 19 | 20 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 21 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 22 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 23 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 24 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 25 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 26 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 27 | 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 28 | }; 29 | 30 | INCLUDE_ASM(s32, "lib/sn/udivmoddi4", __udivmoddi4); 31 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_0.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern void (*D_8009F070[9])(); 5 | 6 | void func_8001DE00() 7 | { 8 | u32 i; 9 | for (i = 0; i < 9; i++) 10 | { 11 | D_8009F070[i](); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | struct unkfunc_8001DE50_sub { 7 | f32 unk0[9]; 8 | }; 9 | 10 | struct unkfunc_8001DE50_arg0 { 11 | s32 unk0; 12 | struct unkfunc_8001DE50_arg1 *unk4; 13 | Vec3f unk8; 14 | s32 unk14; 15 | s32 unk18; 16 | s32 unk1C; 17 | Mtx3f unk20; 18 | // f32 unk20[2][4]; 19 | // s32 unk40; 20 | s32 unk44; 21 | s32 unk48; 22 | s32 unk4C; 23 | s32 unk50; 24 | }; 25 | 26 | struct unkfunc_8001DE50_arg1 { 27 | s32 unk0; 28 | s32 unk4; 29 | s32 unk8; 30 | s32 unkC; 31 | s32 unk10; 32 | s32 unk14; 33 | Mtx3f unk18; 34 | // f32 unk18[2][4]; 35 | // s32 unk38; 36 | Vec3f unk3C; 37 | }; 38 | 39 | void func_80056BD0(void*); 40 | 41 | void func_8001DE50(struct unkfunc_8001DE50_arg0 *arg0, struct unkfunc_8001DE50_arg1 *arg1) 42 | { 43 | arg0->unk4 = arg1; 44 | VEC3F_COPY(arg0->unk8, arg1->unk3C); 45 | MTX3F_COPY(arg0->unk20, arg1->unk18); 46 | func_80056BD0(&arg0->unk50); 47 | } 48 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_103.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "mathutils.h" 5 | 6 | void vec3f_scale(f32, Vec3f, Vec3f); 7 | f32 vec3f_magnitude(Vec3f); 8 | 9 | struct unkfunc_8003CBD0 { 10 | u8 padding[0x230]; 11 | f32 unk230; 12 | }; 13 | 14 | // TODO unify with unkfunc_800263B4 15 | void func_800263B4(struct unkfunc_8003CBD0 *arg0); 16 | 17 | void func_8003CBD0(struct unkfunc_8003CBD0 *arg0) { 18 | func_800263B4(arg0); 19 | arg0->unk230 = 1.0; 20 | } 21 | 22 | struct unkfunc_8003CC04 { 23 | u8 pad[0x24]; 24 | Vec3f unk24; 25 | u8 pad2[0x230 - 0x24 - 0xC]; 26 | f32 unk230; 27 | }; 28 | 29 | struct unkfunc_8003CC04_2_inner { 30 | Vec3f unk0; 31 | u8 pad[0x18 - 0xC]; 32 | Vec3f unk18; 33 | u8 pad2[0x30 - 0x18 - 0xC]; 34 | }; 35 | 36 | struct unkfunc_8003CC04_2 { 37 | struct unkfunc_8003CC04_2_inner unk0[2]; 38 | u32 unk60; 39 | Vec3f unk64; 40 | }; 41 | 42 | void func_8003CC04(struct unkfunc_8003CC04* arg0, struct unkfunc_8003CC04_2* arg1, s32 arg2) { 43 | Vec3f sp10; 44 | struct unkfunc_8003CC04_2_inner* temp_s0; 45 | f32 phi_f0; 46 | 47 | vec3f_cross_product(arg0->unk24, arg1->unk64, sp10); 48 | phi_f0 = vec3f_magnitude(sp10); 49 | 50 | if (phi_f0 < 0.01f) { 51 | return; 52 | } 53 | 54 | if (arg2 == 1) { 55 | phi_f0 = -phi_f0; 56 | } 57 | 58 | temp_s0 = &arg1->unk0[arg2]; 59 | vec3f_scale(arg0->unk230 / phi_f0, sp10, sp10); 60 | temp_s0->unk18[0] = temp_s0->unk18[0] - sp10[0]; 61 | temp_s0->unk18[1] = temp_s0->unk18[1] - sp10[1]; 62 | temp_s0->unk18[2] = temp_s0->unk18[2] - sp10[2]; 63 | } 64 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_104.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_104", func_8003CCE0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_105.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_105", func_8003CD50); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_105", func_8003CF04); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_106.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_8003CFD0 { 5 | u8 padding[0x18]; 6 | s32 unk18[0x09]; 7 | s32 unk3C; 8 | }; 9 | 10 | void func_8003CFD0(struct unkfunc_8003CFD0 *arg0, s32 arg1) 11 | { 12 | arg0->unk18[arg0->unk3C++] = arg1; 13 | } 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_106", func_8003CFEC); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_106", func_8003D064); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_106", func_8003D0D8); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_106", func_8003D12C); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_106", func_8003D15C); 24 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_107.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_107", func_8003D310); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_107", func_8003D604); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_108.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_108", func_8003D770); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_109.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_109", func_8003D810); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_109", func_8003D87C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_109", func_8003D9AC); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_109", func_8003D9C8); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_109", func_8003DA7C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_109", func_8003E404); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_109", func_8003E464); 18 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_110.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_110", func_8003E750); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_111.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void func_80085094(s32); 5 | void func_80084A88(s32); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_111", func_8003EAE0); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_111", func_8003ED98); 10 | 11 | void func_8003F1D4(s32 arg0) 12 | { 13 | func_80085094(arg0 + 0x290); 14 | } 15 | 16 | void func_8003F1F4(s32 arg0) 17 | { 18 | func_80084A88(arg0 + 0x290); 19 | } 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_111", func_8003F214); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_111", func_8003F350); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_111", func_8003F39C); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_111", func_8003F440); 28 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_114.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_114", func_8003F4C0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_115.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | // TODO unify with unkfunc_8007F580 6 | struct unkfunc_80041414 { 7 | u8 padding[0x230]; 8 | s32 unk230; 9 | s32 unk234; 10 | }; 11 | 12 | void func_80085094(s32); 13 | void func_80084A88(s32); 14 | void func_8007F580(struct unkfunc_80041414*); 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_80040220); 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_800402CC); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_800406E8); 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_80040744); 23 | 24 | const Vec3f D_8001B0A0 = { 1.5f, -0.025f, 0.0f }; 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_800407A4); 27 | 28 | void func_800409CC(s32 arg0) 29 | { 30 | func_80085094(arg0 + 0x268); 31 | } 32 | 33 | void func_800409EC(s32 arg0) 34 | { 35 | func_80084A88(arg0 + 0x268); 36 | } 37 | 38 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_80040A0C); 39 | 40 | void func_80040FDC(void) { 41 | 42 | } 43 | 44 | 45 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_80040FE4); 46 | 47 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_800410F4); 48 | 49 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_80041264); 50 | 51 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_80041298); 52 | 53 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_8004133C); 54 | 55 | void func_80041414(struct unkfunc_80041414 *arg0) 56 | { 57 | func_8007F580(arg0); 58 | arg0->unk234 = 0; 59 | arg0->unk230 = 0; 60 | } 61 | 62 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_80041444); 63 | 64 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_115", func_800414C8); 65 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_116.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_116", func_800415D0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_116", func_80041638); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_116", func_80041698); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_116", func_8004178C); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_117.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_117", func_80041890); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_117", func_80041908); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_118.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | s32 func_80041A30(s32 arg0) 5 | { 6 | s32 ret; 7 | if (arg0 < 80) 8 | { 9 | ret = 1; 10 | } 11 | else if (arg0 < 96) 12 | { 13 | ret = 5; 14 | } 15 | else 16 | { 17 | ret = 10; 18 | } 19 | return ret; 20 | } 21 | 22 | extern u8 D_800A58F0[0x88]; 23 | extern s32 D_800A63C4; 24 | 25 | void func_8007A158(); 26 | 27 | void func_80041A54() 28 | { 29 | bzero(D_800A58F0, sizeof(D_800A58F0)); 30 | func_8007A158(); 31 | D_800A63C4 = 0; 32 | } 33 | 34 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_118", func_80041A88); 35 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_119.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_119", func_80041AD0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_119", func_80041F08); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_119", func_80042188); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_119", func_80042348); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_119", func_800423B4); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_119", func_80042474); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_119", func_800424B0); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_119", func_800425B4); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_121.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_121", func_80042640); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_122.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_122", func_80042710); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_122", func_8004296C); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_123.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern u16* D_800A5990; 5 | 6 | u32 func_80042A50(s32 arg0, u16 *arg1); 7 | 8 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_123", func_800429C0); 9 | 10 | s32 func_80042A28(s32 arg0) 11 | { 12 | return func_80042A50(arg0, D_800A5990); 13 | } 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_124.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | u32 func_80042A50(s32 arg0, u16 *arg1) { 5 | return (arg1[6] & 0xfff) & (1ULL << arg0); 6 | } 7 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_125.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkD_800A5990 { 5 | u64 unk0; 6 | u64 unk8; 7 | }; 8 | 9 | extern struct unkD_800A5990 *D_800A5990; 10 | 11 | s32 func_80042AC8(s32 arg0, struct unkD_800A5990 *arg1); 12 | 13 | s32 func_80042AA0(s32 arg0) 14 | { 15 | return func_80042AC8(arg0, D_800A5990); 16 | } 17 | 18 | // u32 func_80042AC8(s32 arg0, struct unkD_800A5990 *arg1) 19 | // { 20 | // // u64 val; 21 | // // u64 val2; 22 | // u64 masked; 23 | // u32 ret; 24 | // u64 val; 25 | // u32 shift = arg0; 26 | // if (arg0 < 0x40) 27 | // { 28 | // val = arg1->unk0; 29 | // // val = arg1->unk0; 30 | // // val2 = 1ULL << shift; 31 | // // masked = (arg1->unk0) & (1ULL << arg0); 32 | // val &= (1ULL << shift); 33 | // } 34 | // else 35 | // { 36 | // val = arg1->unk8 * 16; 37 | // val &= (1ULL << (shift - 0x40)); 38 | // } 39 | // return val == 0; 40 | // } 41 | 42 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_125", func_80042AC8, s32 arg0, struct unkD_800A5990 *arg1); 43 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_126.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern u8 *D_800A5994; 5 | 6 | void func_80043EF0(); 7 | 8 | s32 func_80042BA0(s32 arg0) 9 | { 10 | return (*D_800A5994) & (1 << arg0); 11 | } 12 | 13 | u32 func_80042BBC(u32 arg0) 14 | { 15 | return (((*D_800A5994) & 0x7F) ^ 0x7F) < 1; 16 | } 17 | 18 | s32 func_80042BD8() 19 | { 20 | s32 val = *D_800A5994; 21 | s32 a = 0; 22 | while (val) 23 | { 24 | val &= (val - 1); 25 | a++; 26 | } 27 | return a; 28 | } 29 | 30 | u8 func_80042C04() 31 | { 32 | return *D_800A5994 & 0x80; 33 | } 34 | 35 | extern u32 D_800A5970; 36 | 37 | void func_80042C18() 38 | { 39 | *D_800A5994 |= 0x80; 40 | func_80043EF0(); 41 | } 42 | 43 | u32 func_80042C48(u32 arg0) 44 | { 45 | s32 v1 = (D_800A5970 >> 0xB) & 0xFFF; 46 | return v1 & (1 << arg0); 47 | } 48 | 49 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_126", func_80042C68); 50 | 51 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_126", func_80042CA4); 52 | 53 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_126", func_80042D1C); 54 | 55 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_126", func_8004303C); 56 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_127.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_127", func_80043190); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_127", func_8004328C); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_128.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_128", func_800432F0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_128", func_800433BC); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_128", func_8004345C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_128", func_8004354C); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_129.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_129", func_800436D0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_129", func_8004371C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_129", func_800437EC); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_129", func_8004388C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_129", func_8004396C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_129", func_80043A3C); 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_130.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_130", func_80043B10); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_130", func_80043BA4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_130", func_80043C88); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_131.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_131", func_80043CF0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_132.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_132", func_80043EF0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_133.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_133", func_80044190); 6 | 7 | const Vec3f D_8001B314 = { -1.0f, 2.3f, 0.0f }; 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_133", func_800442F4); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_133", func_80044D78); 12 | 13 | struct unkfunc_800451D0 { 14 | u8 padding[0x260]; 15 | s32 unk260; 16 | f32 unk264; 17 | }; 18 | 19 | extern struct { 20 | f32 unk0; 21 | } D_8009FE14; 22 | 23 | void func_800451D0(struct unkfunc_800451D0 *arg0, s32 arg1) 24 | { 25 | if (arg1 != arg0->unk260) 26 | { 27 | arg0->unk260 = arg1; 28 | arg0->unk264 = D_8009FE14.unk0; 29 | } 30 | } 31 | 32 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_133", func_800451F0); 33 | 34 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_133", func_80045250); 35 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_137.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_137", func_80045370); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_138.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "macros.h" 4 | #include "types.h" 5 | 6 | void func_800875E8(struct GameObject *arg0, u32 romAddr, u8 *dataPtr); 7 | 8 | struct unkfunc_800454B0 { 9 | u8 pad[0x2B4]; 10 | f32 unk2B4; 11 | }; 12 | 13 | void func_800454B0(struct unkfunc_800454B0 *arg0, u32 romAddr, u8 *dataPtr) 14 | { 15 | arg0->unk2B4 = FLT_MAX; 16 | func_800875E8((struct GameObject*) arg0, romAddr, dataPtr); 17 | } 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_138", func_800454D8); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_138", func_80045580); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_138", func_80045628); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_138", func_8004570C); 26 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_140.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "macros.h" 4 | #include "types.h" 5 | 6 | struct unkfunc_80045810 { 7 | u8 padding[0x230]; 8 | s32 unk230; 9 | s32 unk234; 10 | s32 pad238; 11 | f32 unk23C; 12 | }; 13 | 14 | void func_800875E8(struct GameObject *arg0, u32 romAddr, u8 *dataPtr); 15 | 16 | void func_80045810(struct unkfunc_80045810 *arg0, u32 romAddr, u8 *dataPtr) 17 | { 18 | arg0->unk234 = 3; 19 | func_800875E8((struct GameObject*) arg0, romAddr, dataPtr); 20 | } 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045834); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_800458E4); 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045A54); 27 | 28 | struct unkfunc_80045B60 { 29 | u8 pad[0x23C]; 30 | f32 unk23C; 31 | }; 32 | 33 | void func_80045B60(struct unkfunc_80045810 *arg0, u32 romAddr, u8 *dataPtr) 34 | { 35 | arg0->unk23C = FLT_MAX; 36 | func_800875E8((struct GameObject*) arg0, romAddr, dataPtr); 37 | } 38 | 39 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045B88); 40 | 41 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045BE0); 42 | 43 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045C40); 44 | 45 | void func_80045D78(struct unkfunc_80045810 *arg0, u32 romAddr, u8 *dataPtr) 46 | { 47 | arg0->unk230 = -1; 48 | func_800875E8((struct GameObject*) arg0, romAddr, dataPtr); 49 | } 50 | 51 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045D9C); 52 | 53 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045E14); 54 | 55 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045ED8); 56 | 57 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80045F54); 58 | 59 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_8004612C); 60 | 61 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_140", func_80046198); 62 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_144.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "codeseg2.h" 4 | #include "mem.h" 5 | 6 | extern f32 D_8001B420; 7 | 8 | void func_80089D5C(Gfx **dlPtr); 9 | void func_8008AAEC(Gfx **dlHead); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_144", func_80046200); 12 | 13 | void func_80046268(Gfx **dlPtr) 14 | { 15 | func_80089D5C(dlPtr); 16 | D_800A5C3C.unk34 = alloc_second_heap(0x3C00); 17 | D_800C0440.unk10 = 1.0f; 18 | D_800C0440.unk14 = 1.0f; 19 | D_800A5C3C.unk28 = 0; 20 | D_800C0440.unk18 = 0xFF; 21 | D_800C0440.unk19 = 0xFF; 22 | D_800C0440.unk1A = 0xFF; 23 | D_800C0440.unk1B = 0xFF; 24 | D_800C0440.unk0 = 0x14; 25 | D_800C0440.unk4 = 0x14; 26 | D_800C0440.unk8 = 0x140; 27 | D_800C0440.unkC = 1; 28 | } 29 | 30 | void func_800462E4(Gfx **dlHead) 31 | { 32 | func_8008AAEC(dlHead); 33 | (*dlHead)--; 34 | } 35 | 36 | void func_80046318(s32 arg0, s32 arg1) 37 | { 38 | D_800C0440.unk8 = arg0; 39 | D_800C0440.unkC = arg1; 40 | } 41 | 42 | void func_8004632C(s32 arg0, s32 arg1) 43 | { 44 | D_800C0440.unk0 = arg0; 45 | D_800C0440.unk4 = arg1; 46 | } 47 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_145.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "codeseg2.h" 4 | 5 | void func_80046340(f32 arg0, f32 arg1) 6 | { 7 | D_800C0440.unk10 = arg0; 8 | D_800C0440.unk14 = arg1; 9 | } 10 | 11 | void func_80046354(u8 arg0, u8 arg1, u8 arg2, u8 arg3) 12 | { 13 | D_800C0440.unk18 = arg0; 14 | D_800C0440.unk19 = arg1; 15 | D_800C0440.unk1A = arg2; 16 | D_800C0440.unk1B = arg3; 17 | } 18 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_146.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "codeseg2.h" 4 | 5 | extern void* D_800A5C30[3]; 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_146", func_80046370); 8 | 9 | s32 func_8004667C(struct unkD_800A5C3C*, s32, void**, s32, s32, s32, s32, s32); /* extern */ 10 | void func_80088988(struct unkD_800A5C3C*, s32, s32); /* extern */ 11 | void func_80089F18(struct unkD_800A5C3C*); /* extern */ 12 | void func_8008ABE4(struct unkD_800A5C3C*, u8, u8, u8, u8); /* extern */ 13 | void func_8008ABFC(struct unkD_800A5C3C*, f32, f32); /* extern */ 14 | 15 | s32 func_800463B4(struct GfxContext* arg0, s32 arg1, s32 arg2, s32 arg3, s32 arg4) { 16 | Gfx* temp_s4; 17 | s32 temp_s2; 18 | 19 | temp_s4 = arg0->dlHead; 20 | temp_s2 = func_8004667C(&D_800A5C3C, arg1, D_800A5C30, D_800C0440.unk8, D_800C0440.unkC, arg2, arg3, arg4); 21 | func_80088988(&D_800A5C3C, D_800C0440.unk0, D_800C0440.unk4); 22 | func_8008ABE4(&D_800A5C3C, D_800C0440.unk18, D_800C0440.unk19, D_800C0440.unk1A, D_800C0440.unk1B); 23 | func_8008ABFC(&D_800A5C3C, D_800C0440.unk10, D_800C0440.unk14); 24 | D_800A5C3C.unk3C = temp_s4; 25 | D_800A5C3C.unk38 = temp_s4; 26 | D_800A5C3C.unk2A = ((uintptr_t)arg0->unkC - (uintptr_t)arg0->dlHead) / sizeof(Gfx); 27 | func_80089F18(&D_800A5C3C); 28 | arg0->dlHead = D_800A5C3C.unk3C - 1; 29 | return temp_s2; 30 | } 31 | 32 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_146", func_800464AC); 33 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_147.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_147", func_80046500); 6 | 7 | // Converts a number between 0 and 999 to a string 8 | void func_80046578(char *digitsOut, s32 value) { 9 | s32 divisor = 100; 10 | char *curDigit = digitsOut; 11 | 12 | // Decrease the divisor until it's no bigger than the input value 13 | while ((value / divisor) == 0) { 14 | divisor /= 10; 15 | if (divisor <= 1) break; 16 | } 17 | 18 | // Repeatedly divide the input until we get to the ones place 19 | do { 20 | // Divide the value by the current divisor and offset by ascii '0' to get the digit's character 21 | *curDigit = (value / divisor) + '0'; 22 | // Remove the highest digit by taking the remainder of the previous division 23 | value %= divisor; 24 | // Move the divisor down by 1 digit 25 | divisor /= 10; 26 | // Increment the output position 27 | curDigit++; 28 | } while (divisor != 0); 29 | 30 | // Null-terminate the string 31 | *curDigit = '\0'; 32 | } 33 | 34 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_147", func_8004667C); 35 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_148.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | void func_80046A90(s32 *arg0) 6 | { 7 | arg0[0] = 0; 8 | arg0[1] = 0; 9 | arg0[2] = 0; 10 | arg0[3] = 0; 11 | arg0[4] = 0; 12 | arg0[5] = 0; 13 | } 14 | 15 | s32 main_alloc_copy(s32, s32); 16 | 17 | void func_80046AAC(s32 *arg0, s32 *arg1) 18 | { 19 | arg0[0] = arg1[0]; 20 | arg0[1] = main_alloc_copy(arg1[0] * 12,arg1[1]); 21 | arg0[2] = arg1[2]; 22 | arg0[3] = main_alloc_copy(arg1[2] * 24,arg1[3]); 23 | arg0[4] = arg1[4]; 24 | arg0[5] = arg1[5]; 25 | } 26 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_149.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "include_asm.h" 3 | #include "gfx.h" 4 | 5 | // bss 6 | extern struct GfxTask D_800C1460[2]; 7 | extern Gfx D_800C1770[2][0x1000]; 8 | 9 | 10 | extern struct GfxContext gGfxContext; 11 | extern Gfx D_800A5CC0[]; 12 | 13 | extern u8 *D_800AAF6C; 14 | extern u8 *D_800AAF70; 15 | extern struct GfxTask* gCurGfxTask; 16 | 17 | // void func_80046CBC(); 18 | void update_gfx_context(); 19 | void schedule_gfx_task(void); 20 | void func_80046D58(); 21 | void func_80046CBC(); 22 | 23 | void func_80046B40() 24 | { 25 | u32 i; 26 | struct GfxTask *task; 27 | osViSetSpecialFeatures(OS_VI_DITHER_FILTER_ON | OS_VI_GAMMA_OFF); 28 | for (i = 0; i < 2; i++) 29 | { 30 | task = &D_800C1460[i]; 31 | if (i == 0) 32 | { 33 | task->framebuffer = D_800AAF6C; 34 | } 35 | else 36 | { 37 | task->framebuffer = D_800AAF70; 38 | } 39 | bzero(task->framebuffer, FRAMEBUFFER_BYTES); 40 | task->unk124 = 2; 41 | task->ctx.dlHead = task->ctx.dlStart = D_800C1770[i]; 42 | task->ctx.unk0 = 0x1000 * sizeof(Gfx); 43 | task->unk128 = task; 44 | task->ctx.unkC = (Mtx*)((u32)task->ctx.dlStart + task->ctx.unk0); 45 | task->unk120 = i; 46 | } 47 | gCurGfxTask = &D_800C1460[2]; 48 | D_800AAF78[0] = K0BASE; 49 | func_80046CBC(); 50 | update_gfx_context(); 51 | func_80046D58(); 52 | gSPDisplayList(NEXT_GFX(gGfxContext.dlHead), D_800A5CC0); 53 | draw_rectangle(0, 0, 0, 0xFF, 0x12, 0xE, 0x12D, 0xE1); 54 | schedule_gfx_task(); 55 | } 56 | 57 | extern s32 D_800AAF7C; 58 | 59 | void func_80046CBC(void) { 60 | s32 temp_v1_2; 61 | 62 | if ((uintptr_t)++gCurGfxTask >= (uintptr_t) &D_800C1460[2]) { 63 | gCurGfxTask = &D_800C1460[0]; 64 | } 65 | if (D_8009F094.unk0 != 0) { 66 | temp_v1_2 = D_8009F094.unk0->unk128[gCurGfxTask->unk120]; 67 | if (temp_v1_2 != 0) { 68 | D_800AAF7C = temp_v1_2; 69 | } 70 | } 71 | } 72 | 73 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_152.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "gfx.h" 6 | 7 | void func_800476A0(Gfx *arg0, Vtx * arg1, u32 arg2, u32 arg3) 8 | { 9 | gSPVertex(arg0, arg1, arg2, arg3); 10 | } 11 | 12 | // extern f32 D_8001B430; 13 | // extern f32 D_8001B434; 14 | // extern f32 D_8001B438; 15 | // extern f32 D_8001B448; 16 | extern Vec3f D_800A5DC0; 17 | 18 | extern struct GfxContext gGfxContext; 19 | 20 | struct test { 21 | f32 a; 22 | f32 b; 23 | f32 c; 24 | }; 25 | 26 | void load_translation_mtx(f32 *translation) 27 | { 28 | Mtx temp; 29 | Mtx *newMtx; 30 | float scale = 16.0f; 31 | float inverseScale = 1 / scale; 32 | VEC3F_COPY(D_800A5DC0, translation); 33 | newMtx = --gGfxContext.unkC; 34 | guTranslate(newMtx, translation[0] * scale, translation[1] * scale, translation[2] * scale); 35 | guScale(&temp, inverseScale, inverseScale, inverseScale); 36 | guMtxCatL(&temp, newMtx, newMtx); 37 | gSPMatrix(NEXT_GFX(gGfxContext.dlHead), newMtx, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_PUSH); 38 | } 39 | 40 | void pop_matrix() 41 | { 42 | gSPPopMatrix(NEXT_GFX(gGfxContext.dlHead), G_MTX_MODELVIEW); 43 | } 44 | 45 | struct unkfunc_800477D8_inner { 46 | u8 unk0; 47 | u8 unk1; 48 | u8 unk2; 49 | u8 unk3; 50 | }; 51 | 52 | struct unkfunc_800477D8 { 53 | s16 unk0[3]; 54 | s16 unk6; 55 | s16 unk8; 56 | s16 unkA; 57 | struct unkfunc_800477D8_inner unkC; 58 | }; 59 | 60 | void func_800477D8(struct unkfunc_800477D8 *arg0, Vec3f arg1, struct unkfunc_800477D8_inner arg2) 61 | { 62 | s32 i; 63 | for (i = 0; i < 3; i++) 64 | { 65 | arg0->unk0[i] = (arg1[i] - D_800A5DC0[i]) * 256.0f; 66 | } 67 | 68 | arg0->unkC = arg2; 69 | } 70 | 71 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_152", func_80047844); 72 | 73 | void func_80047908(struct unkfunc_800477D8 *arg0, Vec3f arg1, struct unkfunc_800477D8_inner arg2, s32 arg3, s32 arg4) 74 | { 75 | s32 i; 76 | for (i = 0; i < 3; i++) 77 | { 78 | arg0->unk0[i] = (arg1[i] - D_800A5DC0[i]) * 256.0f; 79 | } 80 | 81 | arg0->unkC = arg2; 82 | arg0->unk8 = arg3; 83 | arg0->unkA = arg4; 84 | } 85 | 86 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_152", func_8004797C); 87 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_153.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "types.h" 4 | #include "codeseg2.h" 5 | 6 | void func_80047B60(struct RenderParams arg0, u32* newCycleType, u32* newRenderMode1, u32* newRenderMode2) { 7 | *newCycleType = arg0.cycleType == 1 ? G_CYC_1CYCLE : G_CYC_2CYCLE; 8 | switch (arg0.renderMode) { 9 | case 1: 10 | *newRenderMode1 = G_RM_AA_ZB_OPA_SURF; 11 | *newRenderMode2 = G_RM_AA_ZB_OPA_SURF2; 12 | break; 13 | case 2: 14 | *newRenderMode1 = G_RM_AA_ZB_OPA_SURF; 15 | *newRenderMode2 = G_RM_AA_ZB_OPA_SURF2; 16 | break; 17 | case 3: 18 | *newRenderMode1 = G_RM_AA_ZB_TEX_EDGE; 19 | *newRenderMode2 = G_RM_AA_ZB_TEX_EDGE2; 20 | break; 21 | case 4: 22 | case 6: 23 | *newRenderMode1 = G_RM_AA_ZB_XLU_SURF; 24 | *newRenderMode2 = G_RM_AA_ZB_XLU_SURF2; 25 | break; 26 | case 5: 27 | case 7: 28 | *newRenderMode1 = G_RM_AA_ZB_XLU_DECAL; 29 | *newRenderMode2 = G_RM_AA_ZB_XLU_DECAL2; 30 | break; 31 | } 32 | if (arg0.cycleType == 2) { 33 | *newRenderMode1 = G_RM_PASS; 34 | } 35 | } 36 | 37 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_154.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_154", func_80047C30); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_154", func_80047DB8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_154", func_80047DF8); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_154", func_80048340); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_154", func_80048DA4); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_154", func_80049130); 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_157.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_157", func_800494C0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_158.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_158", func_800495D0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_158", func_80049934); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_158", func_800499B0); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_158", func_80049BA8); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_158", func_80049D08); 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_16.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | extern struct MaterialGfx *materialTable; 6 | 7 | Gfx *func_800922C4(struct MaterialGfx *, s32); 8 | void func_80086310(void *arg0, s32 arg1, Gfx *arg2); 9 | 10 | void func_80020AF0(struct unkfunc_8009C28C *arg0, s32 arg1, Gfx* arg2) 11 | { 12 | if (arg1 != -1 && arg1 == arg0->unk230) 13 | { 14 | arg0->unk234[0] = materialTable[arg1].materialData.raw; 15 | gSPDisplayList(arg2, func_800922C4((struct MaterialGfx *)arg0->unk234, 1)); 16 | } 17 | else 18 | { 19 | func_80086310(arg0, arg1, arg2); 20 | } 21 | } 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_16", func_80020B6C); 24 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_163.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_163", func_8004C490); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_164.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004C800); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004CC38); 8 | 9 | // plays camera sounds 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004CEB8); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D058); 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D0A4); 15 | 16 | void func_80085094(s32); 17 | 18 | void func_8004D0DC(s32 arg0) 19 | { 20 | func_80085094(arg0 + 0x2AC); 21 | } 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D0FC); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D1F8); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D294); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D2F0); 30 | 31 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D720); 32 | 33 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D87C); 34 | 35 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_164", func_8004D91C); 36 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_167.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_167", func_8004D980); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_167", func_8004DFA0); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_167", func_8004E10C); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_17.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_8007F580 { 5 | u8 padding[0x25C]; 6 | s32 unk25C; 7 | }; 8 | 9 | void func_8007F580(struct unkfunc_8007F580*); 10 | 11 | void func_80020C20(struct unkfunc_8007F580 *arg0) 12 | { 13 | func_8007F580(arg0); 14 | arg0->unk25C = -1; 15 | } 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_171.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkD_800A63C0 { 5 | u8 padding[0x14]; 6 | s32 unk14; 7 | s32 unk18; 8 | struct unkD_800A63C0 *unk1C; 9 | }; 10 | 11 | void func_8007F378(s32); 12 | 13 | extern struct unkD_800A63C0 *D_800A63C0; 14 | extern s32 D_800A63C4; 15 | 16 | void func_8004EC70() 17 | { 18 | struct unkD_800A63C0 *cur = D_800A63C0; 19 | while (cur) 20 | { 21 | cur->unk14 = 0; 22 | cur = cur->unk1C; 23 | } 24 | } 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_171", func_8004EC98); 27 | 28 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_171", func_8004ED04); 29 | 30 | void func_8004EE5C() 31 | { 32 | D_800A63C4 = 0; 33 | func_8007F378(0); 34 | } 35 | 36 | void func_8004EE84(s32 arg0) 37 | { 38 | D_800A63C4 |= arg0 & ~0x4000; 39 | if (arg0 & 0x4000) 40 | { 41 | func_8007F378(0); 42 | } 43 | } 44 | 45 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_171", func_8004EEC4); 46 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_172.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_172", func_8004EF60); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_173.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_173", func_8004F540); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_173", func_8004F67C); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_174.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void func_80084A88(s32*); 5 | 6 | struct unkfunc_8004F6D0 { 7 | u8 pad[0x290]; 8 | s32 unk290; 9 | }; 10 | 11 | void func_8004F6D0(struct unkfunc_8004F6D0 *arg0) 12 | { 13 | func_80084A88(&arg0->unk290); 14 | } 15 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_175.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_175", func_8004F6F0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_176.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_8004F730); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_8004F8D4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_8004F930); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_8004FD78); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_80050318); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_800503B8); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_800505C8); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_800506D4); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_176", func_80050728); 22 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_178.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_178", func_80050840); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_179.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "codeseg2.h" 5 | 6 | s32 func_80050860(s32 arg0) { 7 | return arg0; 8 | } 9 | 10 | void func_8008C148(void*, struct unkfunc_8001DFD0*); 11 | 12 | void func_80050868(struct unkfunc_8001DFD0* arg0, void* arg1, void* arg2) { 13 | arg0->unk4 = 0; 14 | arg0->unkC = arg1; 15 | arg0->unk10 = arg2; 16 | arg0->unk8 = -1; 17 | func_8008C148(arg1, arg0); 18 | } 19 | 20 | s32 func_800508A4() 21 | { 22 | return 0; 23 | } 24 | 25 | s32 func_800508AC() 26 | { 27 | return 0; 28 | } 29 | 30 | struct unkfunc_800508B4 { 31 | u8 padding[0x10]; 32 | struct unkfunc_800508B4 *unk10; 33 | }; 34 | 35 | struct unkfunc_800508B4 *func_800508B4(struct unkfunc_800508B4 *arg0) 36 | { 37 | while (arg0->unk10) 38 | { 39 | arg0 = arg0->unk10; 40 | } 41 | return arg0; 42 | } 43 | 44 | s32 func_800508D8(struct unkfunc_800508B4 *arg0, struct unkfunc_800508B4 *arg1) 45 | { 46 | while (arg0) 47 | { 48 | if (arg0 == arg1) 49 | { 50 | return 1; 51 | } 52 | arg0 = arg0->unk10; 53 | } 54 | return 0; 55 | } 56 | 57 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_179", func_800508FC); 58 | 59 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_179", func_80050948); 60 | 61 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_179", func_8005098C); 62 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_18.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_18", func_80020C50); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_18", func_80020CC8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_18", func_80020EBC); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_18", func_80020F88); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_180.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_180", func_800509F0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_180", func_80050A44); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_181.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_181", func_80050AB0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_181", func_80050B08); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_181", func_80050B78); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_181", func_80050BD8); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_181", func_80050C58); 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_182.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_182", func_80050CD0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_182", func_80050D5C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_182", func_80050E24); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_183.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_183", func_80051150); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_183", func_800512BC); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_184.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_184", func_80051310); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_184", func_8005159C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_184", func_8005163C); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_185.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_185", func_80051770); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_185", func_80051938); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_185", func_80051B20); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_185", func_80051CF0); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_185", func_80051F5C); 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_188.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_188", func_800520F0); 6 | 7 | // This plays the ticket get sound 8 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_188", func_80052124); 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_188", func_80052374); 11 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_189.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_189", func_80052500); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_19.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_19", func_80021080); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_190.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_190", func_80052770); 6 | 7 | s32 func_800527F8(s32 *arg0, s32 arg1) 8 | { 9 | return arg0[0x0D] + (arg1 * arg0[0x0C]); 10 | } 11 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_191.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | s32 func_80052810(s32 *arg0, s32 arg1) 5 | { 6 | return arg0[0x0D] + (arg1 * arg0[0x0C]); 7 | } 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_192.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80052830); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_800528A8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80052938); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80052D0C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80052E3C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80052E84); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80053020); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80053104); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_800532C8); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80053584); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_800536D8); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80053F58); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80054700); 30 | 31 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80054844); 32 | 33 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_8005498C); 34 | 35 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80054BBC); 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_192", func_80054F20); 38 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_196.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_196", func_80055460); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_196", func_80055594); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_197.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_80055690); 6 | 7 | void func_80055B2C(f32 *arg0, f32* arg1) 8 | { 9 | arg0[0x8C] = arg1[0x1D]; // TODO probably a struct 10 | arg1[0x1D] = 0; 11 | } 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_80055B3C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_80055D14); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_80055ED4); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_80055F14); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_800561D4); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_800568DC); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_80056AE8); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_197", func_80056B88); 28 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_2", func_8001DED0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_20.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_20", func_80021110); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_20", func_80021138); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_20", func_80021174); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_20", func_80021CEC); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_20", func_80021DCC); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_20", func_80021E48); 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_203.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | f32 vec3f_magnitude(); 6 | void vec3f_scale(f32, Vec3f, Vec3f); 7 | void mtx3f_rotate_axis(f32, Vec3f, Mtx3f); 8 | 9 | void mtx3f_axis_angle(Vec3f in, Mtx3f out) 10 | { 11 | float magnitude; 12 | Vec3f normalized; 13 | 14 | magnitude = vec3f_magnitude(in); 15 | if (magnitude > 1.0E-4f) { // magnitude > 1E-4 16 | vec3f_scale(1.0f / magnitude, in, normalized); // vec3f_scale(1 / magnitude, in, normalized) 17 | mtx3f_rotate_axis(magnitude, normalized, out); 18 | } 19 | else { 20 | // build identity matrix 21 | bzero(out, sizeof(Mtx3f)); 22 | out[0][0] = out[1][1] = out[2][2] = 1.0f; // 1.0f 23 | } 24 | } 25 | 26 | void mtx4f_compose(Vec3f translation, Mtx3f rotation, Mtx4f out) 27 | { 28 | s32 i,j; 29 | for (i = 0; i < 3; i++) 30 | { 31 | for (j = 0; j < 3; j++) 32 | { 33 | out[i][j] = rotation[i][j]; 34 | } 35 | } 36 | for (i = 0; i < 3; i++) 37 | { 38 | out[3][i] = translation[i]; 39 | } 40 | for (i = 0; i < 3; i++) 41 | { 42 | out[i][3] = 0; 43 | } 44 | out[3][3] = 1.0f; 45 | } 46 | 47 | void mtx4f_decompose(Mtx4f in, Vec3f translation, Mtx3f rotation) 48 | { 49 | s32 i,j; 50 | if (rotation) 51 | { 52 | for (i = 0; i < 3; i++) 53 | { 54 | for (j = 0; j < 3; j++) 55 | { 56 | rotation[i][j] = in[i][j]; 57 | } 58 | } 59 | } 60 | if (translation) 61 | { 62 | for (i = 0; i < 3; i++) 63 | { 64 | translation[i] = in[3][i]; 65 | } 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_204.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "mathutils.h" 5 | 6 | f32 clampf_abs(f32, f32); 7 | void func_80057708(Mtx3f a, Mtx3f b, Mtx3f out); 8 | 9 | f32 func_80057280(Mtx3f arg0) 10 | { 11 | // Calculate the trace of the matrix (sum of primary diagonal) 12 | f32 trace = arg0[0][0] + arg0[1][1] + arg0[2][2]; 13 | // Convert the trace to the cosine of the matrix's rotational angle 14 | return clampf_abs((trace - 1.0) * 0.5, 1.0); 15 | } 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_204", func_800572D8); 18 | 19 | void vec3f_scale(f32, Vec3f, Vec3f); 20 | 21 | void func_8005759C(Vec3f arg0, Vec3f arg1) 22 | { 23 | Vec3f sp10; 24 | f32 sp20; 25 | func_800572D8(arg0, &sp20, sp10); 26 | vec3f_scale(sp20, sp10, arg1); 27 | } 28 | 29 | void func_800575DC(Mtx3f arg0) 30 | { 31 | vec3f_normalize(arg0[0]); 32 | vec3f_cross_product(arg0[0], arg0[1], arg0[2]); 33 | vec3f_normalize(arg0[2]); 34 | vec3f_cross_product(arg0[2], arg0[0], arg0[1]); 35 | vec3f_normalize(arg0[1]); 36 | } 37 | 38 | void vec3f_transpose_rotate(Mtx3f mat, Vec3f in, Vec3f out) 39 | { 40 | out[0] = mat[0][0] * in[0] + mat[0][1] * in[1] + mat[0][2] * in[2]; 41 | out[1] = mat[1][0] * in[0] + mat[1][1] * in[1] + mat[1][2] * in[2]; 42 | out[2] = mat[2][0] * in[0] + mat[2][1] * in[1] + mat[2][2] * in[2]; 43 | } 44 | 45 | void func_800576E0(Mtx3f a, Mtx3f b, Mtx3f out) 46 | { 47 | func_80057708(b, a, out); 48 | } 49 | 50 | void func_80057708(Mtx3f a, Mtx3f b, Mtx3f out) 51 | { 52 | s32 i, j; 53 | for (i = 0; i < 3; i++) 54 | { 55 | for (j = 0; j < 3; j++) 56 | { 57 | out[i][j] = 58 | a[0][j] * b[0][i] + 59 | a[1][j] * b[1][i] + 60 | a[2][j] * b[2][i]; 61 | } 62 | } 63 | } 64 | 65 | void func_80057778(Mtx3f a, Mtx3f b, Mtx3f out) 66 | { 67 | s32 i, j; 68 | for (i = 0; i < 3; i++) 69 | { 70 | for (j = 0; j < 3; j++) 71 | { 72 | out[i][j] = 73 | a[j][0] * b[i][0] + 74 | a[j][1] * b[i][1] + 75 | a[j][2] * b[i][2]; 76 | } 77 | } 78 | } 79 | 80 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_204", func_800577E8); 81 | 82 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_204", func_800578C0); 83 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_209.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_209", func_80058050); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_209", func_8005809C); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_21.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_21", func_80021F10); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_21", func_80021FC8); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_210.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_800580E0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_80058488); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_80058504); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005863C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_80058EC0); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_80058F68); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005908C); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_80059204); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_800592B4); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_80059BD8); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_80059E44); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_80059F14); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005A0F8); 30 | 31 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005A130); 32 | 33 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005A70C); 34 | 35 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005A7F8); 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005A9F8); 38 | 39 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005AAE0); 40 | 41 | s32 func_8005BE44() 42 | { 43 | return 0; 44 | } 45 | 46 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005BE4C); 47 | 48 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005BEF4); 49 | 50 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_210", func_8005C038); 51 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_214.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_214", func_8005C0F0); 8 | 9 | struct unkfunc_8005C210 { 10 | u8 pad1[0x268]; 11 | struct GameObject* unk268; 12 | struct GameObject* unk26C; 13 | struct GameObject* unk270; 14 | u8 pad2[0x2A0 - 0x274]; 15 | struct GameObject* unk2A0; 16 | u8 pad3[0x7D0 - 0x2A4]; 17 | f32 unk7D0; 18 | }; 19 | 20 | void obj_set_rotation_axis_angle_xyz(struct GameObject *obj, f32 x, f32 y, f32 z); 21 | void obj_rotate_axis_angle_xyz(struct GameObject* obj, f32 x, f32 y, f32 z); 22 | void obj_translate(struct GameObject* obj, Vec3f translation); 23 | void func_8001FDB4(struct GameObject *arg0, struct GameObject *arg1, Vec3f arg2, Vec3f arg3); 24 | void func_800605A4(struct unkfunc_8005C210*, f32*, f32*); 25 | 26 | // TODO some types seem wrong here, as a Mtx3f is being passed to a Vec3f argument 27 | void func_8005C210(struct unkfunc_8005C210* arg0) { 28 | Vec3f sp10; 29 | Vec3f sp20; 30 | Vec3f sp30; 31 | f32 sp40; 32 | f32 sp44; 33 | 34 | func_800605A4(arg0, &sp40, &sp44); 35 | arg0->unk26C->unk0->unk58(arg0->unk26C, arg0->unk268->position); 36 | obj_set_rotation_axis_angle_xyz(arg0->unk26C, 0.0f, -sp40, 0.0f); 37 | func_8001FDB4(arg0->unk2A0->unk10, (struct GameObject* ) arg0, arg0->unk2A0->rotation[0], sp10); 38 | arg0->unk270->unk0->unk58(arg0->unk270, sp10); 39 | obj_set_rotation_axis_angle_xyz(arg0->unk270, 0.0f, -sp44, 0.0f); 40 | obj_rotate_axis_angle_xyz(arg0->unk26C, 0.0f, arg0->unk7D0, 0.0f); 41 | func_8001FDB4(arg0->unk2A0->unk10, (struct GameObject* ) arg0, arg0->unk2A0->rotation[0], sp20); 42 | VEC3F_SUB(sp30, sp10, sp20); 43 | obj_translate(arg0->unk26C, sp30); 44 | } 45 | 46 | 47 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_214", func_8005C338); 48 | 49 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_214", func_8005C868); 50 | 51 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_214", func_8005CC70); 52 | 53 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_214", func_8005CF48); 54 | 55 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_214", func_8005E2A4); 56 | 57 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_214", func_8005E8A0); 58 | 59 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_214", func_8005EA60); 60 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_219.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_219", func_8005EB60); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_219", func_8005ECA8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_219", func_8005F114); 10 | 11 | void func_8004BB64(s32); 12 | 13 | void func_8005F26C(s32 arg0) 14 | { 15 | func_8004BB64(arg0 + 0x3A4); 16 | } 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_219", func_8005F28C); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_219", func_8005F3CC); 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_219", func_8005FAD0); 23 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_22.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_22", func_80022080); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_22", func_80022138); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_221.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void func_8004C44C(s32); 5 | void func_80083734(void*); 6 | s32 func_800800F0(); 7 | 8 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_8005FC10); 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_8005FC44); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_800601A4); 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_800605A4); 15 | 16 | void func_80060794(s32 arg0) 17 | { 18 | func_8004C44C(arg0 + 0x3A4); 19 | } 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_800607B4); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_8006096C); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_80060DE4); 26 | 27 | void func_80060E5C(void) { 28 | 29 | } 30 | 31 | struct unkfunc_80060E64; 32 | struct unkfunc_80060E64_sub { 33 | u8 padding[0x2C]; 34 | void (*unk2C)(struct unkfunc_80060E64*, s32); 35 | }; 36 | 37 | struct unkfunc_80060E64 { 38 | struct unkfunc_80060E64_sub *unk0; 39 | s32 unk4; 40 | s32 unk8; 41 | s32 unkC; 42 | s32 unk10; 43 | u8 padding[0x230 - 0x10 - 0x04]; 44 | s32 unk230; 45 | }; 46 | 47 | // called by func_80050E24 via jalr with return address 0x80051050 48 | // seems to get called on level load 49 | // arg0->unk0->unk2C seems to always be func_800824A0 50 | void func_80060E64(struct unkfunc_80060E64 *arg0) 51 | { 52 | func_80083734(arg0); 53 | arg0->unk230 = arg0->unk10; 54 | arg0->unk0->unk2C(arg0, 0); 55 | } 56 | 57 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_80060EA8); 58 | 59 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_80061038); 60 | 61 | s32 func_800611A4(s32 arg0, s32 *arg1) 62 | { 63 | if (arg1[1] != 2) 64 | { 65 | return func_800800F0(); 66 | } 67 | else 68 | { 69 | return 1; 70 | } 71 | } 72 | 73 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_221", func_800611D4); 74 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_222.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | extern void *gDepthBuffer; 7 | extern u32 D_800F6ADF; 8 | extern u32 D_800E48A4; 9 | extern u32 D_800E48A0; 10 | extern u32 D_803B5000; 11 | extern u32 D_803DA800; 12 | extern void *D_800AAF6C; 13 | extern u32 D_800AAF70; 14 | extern u32 D_800E48A8; 15 | extern u32 D_800E48AC; 16 | extern void *D_800E48B0; 17 | extern void *D_800E48B4; 18 | extern s32 D_800E48B8; 19 | extern void *D_800E4DA0; 20 | 21 | extern u8 D_800E4990[]; 22 | extern u8 _codeseg2SegmentBssEnd[]; 23 | 24 | // TODO different order? 25 | // void func_80061300() 26 | // { 27 | // gDepthBuffer = ALIGN(_codeseg2SegmentBssEnd, 64); 28 | // bzero(gDepthBuffer, FRAMEBUFFER_BYTES); 29 | // gAudioHeapPtr = D_800E48A4 = FRAMEBUFFER_BYTES + (s32)gDepthBuffer; 30 | // bzero(gAudioHeapPtr, AUDIO_HEAP_SIZE); 31 | // D_800E48A8 = D_800E48A4 = D_800E48AC = D_800E48A0 = AUDIO_HEAP_SIZE + (s32)gAudioHeapPtr; 32 | // D_800AAF70 = RAM_END - FRAMEBUFFER_BYTES; 33 | // D_800E48B0 = D_800E48B4 = D_800AAF6C = RAM_END - (2 * FRAMEBUFFER_BYTES); 34 | // D_800E48B8 = -1; 35 | // D_800E4DA0 = ALIGN(D_800E4990, 16); 36 | // } 37 | 38 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_222", func_80061300); 39 | 40 | u32 func_800613F8(u32 arg0) 41 | { 42 | 43 | if (arg0 == 0) 44 | { 45 | return 0; 46 | } 47 | else 48 | { 49 | u32 iVar1 = D_800E48A0; 50 | D_800E48A4 = D_800E48A8 = D_800E48AC = D_800E48A0 = D_800E48A0 + ALIGN(arg0, 16); 51 | return iVar1; 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_224.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern u32 D_800E4DA0; 5 | extern u32 D_800E4DA4; 6 | extern u32 D_800E4DA8; 7 | 8 | void do_dma_read(u32 romAddr, void *ramAddr, s32 length); 9 | 10 | // Not even close yet 11 | // void dma_read(u32 arg0, u32 arg1, s32 arg2) 12 | // { 13 | // s32 s1; 14 | // while (1) 15 | // { 16 | // if (arg0 >= D_800E4DA4 && arg0 < D_800E4DA8) 17 | // { 18 | // u32 v0 = arg0 - D_800E4DA4; 19 | // if (v0 < 100) 20 | // { 21 | // if ((D_800E4DA0 + v0) & 0x03 == arg1 & 0x03) 22 | // break; 23 | // } 24 | // } 25 | // else 26 | // { 27 | 28 | // do_dma_read(arg0, arg1, s1); 29 | 30 | // D_800E4DA4 = D_800E4DA8 & 0xFFFFFFFE; 31 | // D_800E4DA8 = D_800E4DA4 + 0x400; 32 | // do_dma_read(D_800E4DA4, D_800E4DA0, 0x400); 33 | // } 34 | // } 35 | // } 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_224", dma_read); 38 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_225.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern OSIoMesg D_800E4DB0; 5 | extern OSMesgQueue D_80017DFC; 6 | 7 | void start_dma_read(u32 romAddr, void *ramAddr, s32 length) 8 | { 9 | osInvalDCache(ramAddr, length); 10 | osPiStartDma(&D_800E4DB0, OS_MESG_PRI_NORMAL, OS_READ, romAddr, ramAddr, length, &D_80017DFC); 11 | return; 12 | } 13 | 14 | void do_dma_read(u32 romAddr, void *ramAddr, s32 length) 15 | { 16 | OSMesg dummy; 17 | 18 | osInvalDCache(ramAddr, length); 19 | osPiStartDma(&D_800E4DB0, OS_MESG_PRI_NORMAL, OS_READ, romAddr, ramAddr, length, &D_80017DFC); 20 | osRecvMesg(&D_80017DFC, &dummy, OS_MESG_BLOCK); 21 | } 22 | 23 | struct unkD_800AAF64 { 24 | }; 25 | 26 | struct unkD_800E4DD0 { 27 | u32 romAddr; 28 | u32 ramAddr; 29 | u32 size; 30 | u32 *unkC; 31 | }; 32 | 33 | extern s32 D_800AAF60; 34 | extern s32 D_800AAF64; 35 | extern s32 D_800AF5F0; 36 | extern OSIoMesg D_800E4DB0; 37 | extern OSMesgQueue D_80017DFC; 38 | extern struct unkD_800E4DD0 D_800E4DD0[]; 39 | 40 | void func_80061A58() 41 | { 42 | OSMesg mesg; 43 | if (D_800AAF64 != D_800AAF60) 44 | { 45 | u32 romAddr = D_800E4DD0[D_800AAF60].romAddr; 46 | void *ramAddr = (void *)D_800E4DD0[D_800AAF60].ramAddr; 47 | u32 size = D_800E4DD0[D_800AAF60].size; 48 | osInvalDCache(ramAddr, size); 49 | osPiStartDma(&D_800E4DB0, OS_MESG_PRI_NORMAL, OS_READ, romAddr, ramAddr, size, &D_80017DFC); 50 | if (D_800AF5F0 != -1) 51 | { 52 | osRecvMesg(&D_80017DFC, &mesg, OS_MESG_BLOCK); 53 | *D_800E4DD0[D_800AAF60].unkC = D_800E4DD0[D_800AAF60].ramAddr; 54 | D_800E4DD0[D_800AAF60].unkC = 0; 55 | D_800AAF60 = (D_800AAF60 + 1) % 5; 56 | } 57 | else 58 | { 59 | *D_800E4DD0[D_800AAF60].unkC = 0; 60 | } 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_226.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | struct unkD_800E4DD0 { 6 | u32 romAddr; 7 | u32 ramAddr; 8 | u32 size; 9 | u32 *unkC; 10 | }; 11 | 12 | void func_80061A58(); 13 | 14 | extern struct unkD_800E4DD0 D_800E4DD0[]; 15 | extern s32 D_800AAF60; 16 | extern s32 D_800AAF64; 17 | extern OSMesgQueue D_80017DFC; 18 | 19 | void func_80061B90(u32 romAddr,u32 ramAddr,u32 size,u32 *arg3) 20 | { 21 | s32 index = D_800AAF64; 22 | s32 bVar1; 23 | 24 | D_800E4DD0[index].romAddr = romAddr; 25 | D_800E4DD0[index].ramAddr = ramAddr; 26 | D_800E4DD0[index].size = size; 27 | D_800E4DD0[index].unkC = arg3; 28 | bVar1 = D_800AAF60 == index; 29 | D_800AAF64 = (index + 1) % 5; 30 | *arg3 = 0; 31 | if (bVar1) 32 | { 33 | func_80061A58(); 34 | } 35 | } 36 | 37 | void func_80061C18() 38 | { 39 | OSMesg mesg; 40 | 41 | if (D_800E4DD0[D_800AAF60].unkC) { 42 | if (osRecvMesg(&D_80017DFC, &mesg, OS_MESG_NOBLOCK) == 0) { 43 | *D_800E4DD0[D_800AAF60].unkC = D_800E4DD0[D_800AAF60].ramAddr; 44 | D_800E4DD0[D_800AAF60].unkC = NULL; 45 | D_800AAF60 = (D_800AAF60 + 1) % 5; 46 | } 47 | } 48 | func_80061A58(); 49 | } 50 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_227.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_227", func_80061CE0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_227", func_80061D78); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_228.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_228", func_80061ED0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_228", func_80062160); 8 | 9 | void func_800774DC(); 10 | 11 | void func_8006238C() 12 | { 13 | func_800774DC(); 14 | func_80061ED0(); 15 | } 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_228", func_800623B4); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_228", func_80062408); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_230.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_230", func_80062550); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_230", func_800625D8); 8 | 9 | // plays pause screen noises 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_230", func_80062A94); 11 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_231.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_231", func_800637E0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_232.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern s32 D_800AC2E0; 5 | extern u16 D_800A58F0; 6 | 7 | void func_80078244(s32, s32, f32); 8 | void func_80041A54(); 9 | void func_80041F08(s32); 10 | void func_80041AD0(s32); 11 | void func_80078170(void*, s32); 12 | u32 func_80042A50(s32 arg0, u16 *arg1); 13 | void func_8007F378(s32); 14 | void func_80043EF0(); 15 | void func_800625D8(void*, s32); 16 | void func_8002A86C(s32, s32); 17 | 18 | void func_80063840(s32 arg0) 19 | { 20 | func_80041A54(); 21 | func_80041F08(arg0); 22 | if (arg0 >= 0) 23 | { 24 | s32 tmp; 25 | func_80041AD0(arg0); 26 | func_80078170(&D_800AC2E0, 0); 27 | if (func_80042A50(0, &D_800A58F0)) 28 | { 29 | tmp = 5; 30 | } 31 | else 32 | { 33 | tmp = 7; 34 | } 35 | func_80078244(tmp, -1, 0.3f); 36 | } 37 | else 38 | { 39 | func_8007F378(0); 40 | } 41 | } 42 | 43 | void func_800638CC() 44 | { 45 | func_80043EF0(); 46 | } 47 | 48 | struct unkD_800ABC90 { 49 | u8 padding[0x48]; 50 | s32 unk48; 51 | }; 52 | 53 | extern struct unkD_800ABC90 D_800ABC90; 54 | 55 | void func_80041A54(void); 56 | void func_80078244(s32, s32, f32); 57 | 58 | void func_800638EC() 59 | { 60 | func_80041A54(); 61 | D_800ABC90.unk48 = -1; 62 | func_800625D8(&D_800ABC90, 0); 63 | func_80078244(2, -1, 1.0f); 64 | } 65 | 66 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_232", func_80063934); 67 | 68 | void func_80063A88(s32 arg0) 69 | { 70 | func_8002A86C(arg0, 0xC); 71 | } 72 | 73 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_232", func_80063AA8); 74 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_240.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void func_800824A0(); 5 | 6 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_800662D0); 7 | 8 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_80066430); 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_80066594); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_80066614); 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_80066884); 15 | 16 | void func_80066988(s32 *arg0) 17 | { 18 | arg0[0x8F] = arg0[0x04]; 19 | func_800824A0(); 20 | } 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_800669AC); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_80066A50); 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_80066C38); 27 | 28 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_240", func_80066CA8); 29 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_243.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "types.h" 4 | 5 | void func_800824A0(struct unkfunc_800824A0 *arg0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_243", func_80066D70); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_243", func_80066E3C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_243", func_80066F24); 12 | 13 | void func_80067108(s32 *arg0) 14 | { 15 | arg0[0x8D] = arg0[0x04]; 16 | func_800824A0((struct unkfunc_800824A0*) arg0); 17 | } 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_243", func_8006712C); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_244.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_244", func_80067230); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_244", func_800672B4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_244", func_8006730C); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_245.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_800675B0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_80067894); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_80067D30); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_80068654); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_8006871C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_80068758); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_800687D8); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_80068818); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_245", func_80068858); 22 | 23 | void func_8004BB64(s32); 24 | void func_8004C44C(s32); 25 | 26 | void func_800689F4(s32 arg0) 27 | { 28 | func_8004BB64(arg0 + 0x238); 29 | } 30 | 31 | void func_80068A14(s32 arg0) 32 | { 33 | func_8004C44C(arg0 + 0x238); 34 | } 35 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_247.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_247", func_80068A40); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_247", func_80068A94); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_247", func_80068C24); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_247", func_80068D14); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_248.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_248", func_80068E00); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_261.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "types.h" 4 | 5 | struct unkfunc_8006B430 { 6 | s32 unk0; 7 | s32 unk4; 8 | s32 unk8; 9 | s32 unkC; 10 | s32 unk10; 11 | s32 unk14; 12 | s32 unk18; 13 | }; 14 | 15 | void func_8001FDB4(struct GameObject *arg0, struct GameObject *arg1, Vec3f arg2, Vec3f arg3); 16 | 17 | void func_8006B430(struct GameObject *arg0, Vec3f arg1) 18 | { 19 | func_8001FDB4(arg0->unk10, 0, arg0->rotation[0], arg1); 20 | } 21 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_262.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_262", func_8006B460); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_263.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_263", func_8006B4B0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_263", func_8006B560); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_263", func_8006B648); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_263", func_8006B700); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_263", func_8006B76C); 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_266.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void func_8001E044(struct GameObject *arg0, s32 arg1, u8 *dataPtr, s32 arg3); 6 | 7 | s32 func_80042A28(s32); 8 | void func_8008C590(struct unkfunc_800882B8 *, struct GameObject *); 9 | s32 func_80042BA0(s32); 10 | s32 func_80042AA0(s32); 11 | void func_80087E88(struct unkfunc_80087D4C *arg0, s32 arg1, u8 *dataPtr); 12 | 13 | void func_8006B7C0(struct GameObject *arg0, s32 arg1, u8 *arg2, s32 arg3) { 14 | s32 temp_v0; 15 | 16 | func_8001E044(arg0, arg1, arg2, arg3); 17 | if (func_80042A28(--arg0->unk14C) != 0) { 18 | temp_v0 = arg0->unk114; 19 | if (temp_v0 != 2) { 20 | if (temp_v0 == 0) { 21 | func_8008C590(arg0->unkC, arg0); 22 | } 23 | arg0->unk114 = 2; 24 | } 25 | } 26 | } 27 | 28 | // This can play the ticket get sound 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_266", func_8006B82C); 30 | 31 | void func_8006BA48(struct GameObject *arg0, s32 arg1, u8 *arg2, s32 arg3) { 32 | s32 temp_v0; 33 | 34 | func_8001E044(arg0, arg1, arg2, arg3); 35 | if (func_80042BA0(--arg0->unk14C) != 0) { 36 | temp_v0 = arg0->unk114; 37 | if (temp_v0 != 2) { 38 | if (temp_v0 == 0) { 39 | func_8008C590(arg0->unkC, arg0); 40 | } 41 | arg0->unk114 = 2; 42 | } 43 | } 44 | } 45 | 46 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_266", func_8006BAB4); 47 | 48 | void func_8006BF3C(struct unkfunc_8006BF3C* arg0, s32 arg1); 49 | 50 | // TODO investigate if this is possibly the same struct used as a union 51 | void func_8006BBE4(struct unkfunc_8001E044_2 *arg0, s32 arg1, u8 *arg2) { 52 | void (*temp_v0)(struct GameObject *); 53 | 54 | arg0->unk2C = 0x7FFFFFFF; 55 | // TODO is this cast indicative of game objects having multiple types? 56 | func_80087E88((struct unkfunc_80087D4C*) arg0, arg1, arg2); 57 | if (func_80042AA0(arg0->unk24) != 0) { 58 | func_8006BF3C((struct unkfunc_8006BF3C*) arg0, 2); 59 | } 60 | temp_v0 = arg0->unk0->unk40; 61 | if (temp_v0 != 0) { 62 | temp_v0((struct GameObject*)arg0); 63 | } 64 | } 65 | 66 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_266", func_8006BC4C); 67 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_269.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void func_8006C080(s32 *arg0, s32 arg1, s32 arg2) 5 | { 6 | arg0[3] = arg1; // TODO probably a struct 7 | arg0[4] = arg2; 8 | } 9 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_27.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_27", func_80026050); 6 | 7 | void func_8009A464(s32, s32*); 8 | 9 | void func_800260F4(s32 *arg0) 10 | { 11 | func_8009A464(arg0[0xF], &arg0[0x10]); 12 | } 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_27", func_8002611C); 15 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_270.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_270", func_8006C090); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_270", func_8006C0E4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_270", func_8006C1E4); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_270", func_8006C39C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_270", func_8006C518); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_270", func_8006C5A0); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_270", func_8006C7F4); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_270", func_8006C828); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_272.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_272", func_8006C870); 6 | 7 | extern s32 D_800AB6C4; 8 | extern s32 D_800AB6C8[]; 9 | 10 | void func_8006C968(s32 arg0) 11 | { 12 | D_800AB6C8[D_800AB6C4++] = arg0; 13 | } 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_273.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_273", func_8006C990); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_273", func_8006CA6C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_273", func_8006CAF8); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_274.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_274", func_8006CB60); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_274", func_8006CBA4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_274", func_8006CC34); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_274", func_8006CEC0); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_274", func_8006CF0C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_274", func_8006CF7C); 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_276.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_8006D458 { 5 | u8 padding[0x268]; 6 | u32 unk268; 7 | }; 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_276", func_8006D090); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_276", func_8006D22C); 12 | 13 | void func_80085094(u32*); 14 | void func_80084A88(u32*); 15 | 16 | void func_8006D438(struct unkfunc_8006D458 *arg0) 17 | { 18 | func_80085094(&arg0->unk268); 19 | } 20 | 21 | void func_8006D458(struct unkfunc_8006D458 *arg0) 22 | { 23 | func_80084A88(&arg0->unk268); 24 | } 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_276", func_8006D478); 27 | 28 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_276", func_8006DA84); 29 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_277.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_277", func_8006DAC0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_277", func_8006DBCC); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_278.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "types.h" 4 | 5 | void func_800263B4(struct unkfunc_800263B4 *arg0); 6 | 7 | void func_8006DE20(void* arg0) 8 | { 9 | func_800263B4(arg0); 10 | } 11 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_279.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006DE40); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006DEB8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006DF4C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006E194); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006E370); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006E598); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006E648); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006E6CC); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006EE9C); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006EEE4); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_279", func_8006EF34); 26 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_28.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_800261B0 { 5 | u8 padding[0x18]; 6 | s32 unk18; 7 | s32 unk1C[8]; // TODO real array length 8 | }; 9 | 10 | void func_800261B0(struct unkfunc_800261B0 *arg0, s32 arg1) 11 | { 12 | arg0->unk1C[arg0->unk18++] = arg1; 13 | } 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_281.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_281", func_8006EF70); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_281", func_8006F4A4); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_282.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_8006FD50 { 5 | u8 padding[0xAC]; 6 | u32 unkAC; 7 | }; 8 | 9 | void func_80087554(); 10 | 11 | void func_8006FD50(struct unkfunc_8006FD50 *arg0) 12 | { 13 | arg0->unkAC = -1; 14 | func_80087554(); 15 | } 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_282", func_8006FD74); 18 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_283.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void func_8006FFD4(s32, s32, s32); 5 | 6 | void func_8006FE70(s32 arg0) 7 | { 8 | func_8006FFD4(arg0, 0, -1); 9 | } 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_8006FE94); 12 | 13 | INCLUDE_ASM(void, "rocket/codeseg2/codeseg2_283", func_8006FFD4, s32, s32, s32); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_80070190); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_800701FC); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_80070254); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_800702A8); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_800702E4); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_8007038C); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_80070438); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_283", func_8007060C); 30 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_29.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_29", func_800261D0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_29", func_80026334); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_29", func_800263B4); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_29", func_800263F8); 12 | 13 | s32 func_8002643C() 14 | { 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_293.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_293", func_80073460); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_293", func_80073578); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_293", func_800736D0); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_293", func_800737A4); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_293", func_80073940); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_293", func_800739FC); 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_296.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_80073CE0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_80073DA8); 8 | 9 | const Vec3f D_8001CD6C = { 1.25f, -0.25f, 0.0f }; 10 | const Vec3f D_8001CD78 = { 10.0f, 10.0f, 0.0f }; 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_80073EC8); 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_80074348); 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_800743EC); 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_800744E8); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_800745A0); 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_800746D4); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_296", func_800748F8); 25 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_298.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_298", func_80074A80); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_298", func_80074ADC); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_299.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_299", func_80074C30); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_299", func_80074C88); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_30.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "types.h" 4 | 5 | void func_800263B4(struct unkfunc_800263B4 *); 6 | 7 | void func_80026450(struct unkfunc_800263B4 *arg0) 8 | { 9 | func_800263B4(arg0); 10 | arg0->unk234 = -1; 11 | arg0->unk238 = -1; 12 | } 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_30", func_80026484); 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_30", func_80026504); 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_30", func_80026588); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_30", func_80026644); 21 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_300.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_300", func_80074D70); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_300", func_80074DF4); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_301.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_301", func_80075040); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_301", func_800750A4); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_303.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | extern struct TexturedMaterial *D_800AC1C8[0x44]; 6 | 7 | struct unkfunc_80075940_2 { 8 | s32 digit; 9 | s32 x; 10 | s32 y; 11 | s32 valid; 12 | }; 13 | 14 | struct unkfunc_80075940 { 15 | s32 unk0; 16 | s32 unk4; 17 | s32 bufferLength; 18 | struct unkfunc_80075940_2* buffer; 19 | }; 20 | 21 | struct unkfunc_80075940_2* func_80075940(struct unkfunc_80075940* arg0, struct unkfunc_80075940_2* arg1, s32 val) { 22 | struct TexturedMaterial* digitTexture; 23 | struct unkfunc_80075940_2* cur; 24 | struct unkfunc_80075940_2* end; 25 | s32 divisor; 26 | s32 x; 27 | s32 y; 28 | 29 | x = arg1->x; 30 | y = arg1->y; 31 | divisor = 1000; 32 | while ((val / divisor) == 0) { 33 | divisor /= 10; 34 | if (divisor <= 1) break; 35 | } 36 | do { 37 | arg1->digit = val / divisor; 38 | arg1->x = x; 39 | arg1->y = y; 40 | arg1->valid = 1; 41 | digitTexture = D_800AC1C8[arg1->digit]; 42 | if (digitTexture) { 43 | x += (*digitTexture->textures)->header.width; 44 | } 45 | val = val % divisor; 46 | divisor /= 10; 47 | arg1++; 48 | } while (divisor != 0); 49 | end = &arg0->buffer[arg0->bufferLength]; 50 | cur = arg1; 51 | while (cur < end) { 52 | cur->digit = -1; 53 | cur++; 54 | } 55 | return arg1; 56 | } 57 | 58 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_303", func_80075ABC); 59 | 60 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_303", func_80075BE8); 61 | 62 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_303", func_80075C24); 63 | 64 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_303", func_80075CC8); 65 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_304.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern struct { 5 | f32 unk0; 6 | } D_8009FE14; 7 | 8 | struct unkfunc_80076734 { 9 | u8 padding[0x48]; 10 | s32 unk48; 11 | s32 unk4C; 12 | f32 unk50; 13 | }; 14 | 15 | void func_80076734(struct unkfunc_80076734 *arg0, s32 arg1); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_800765B0); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_8007668C); 20 | 21 | void func_800766E8(struct unkfunc_80076734 *arg0) 22 | { 23 | func_80076734(arg0, 2); 24 | } 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80076708); 27 | 28 | void func_80076734(struct unkfunc_80076734 *arg0, s32 arg1) 29 | { 30 | if (arg1 != arg0->unk48) 31 | { 32 | arg0->unk48 = arg1; 33 | arg0->unk50 = D_8009FE14.unk0; 34 | } 35 | } 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80076754); 38 | 39 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_8007679C); 40 | 41 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80076944); 42 | 43 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80076B54); 44 | 45 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80076C00); 46 | 47 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80076C64); 48 | 49 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80076E58); 50 | 51 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80076EB0); 52 | 53 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_800771E4); 54 | 55 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_800772D8); 56 | 57 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80077498); 58 | 59 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_800774DC); 60 | 61 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80077514); 62 | 63 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_800775A0); 64 | 65 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80077714); 66 | 67 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_304", func_80077774); 68 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_308.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_308", func_800777B0); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_308", func_80077A50); 13 | 14 | extern s32 D_800AC2D8; 15 | extern struct MaterialGfx *materialTable; 16 | extern s32 D_800ABCD8; 17 | extern struct TexturedMaterial *D_800AC1C8[0x44]; 18 | 19 | #define ARRAY_LEN(x) (s32)(sizeof(x) / sizeof((x)[0])) 20 | 21 | // This is probably not the actual inline function used, but there definitely was an inline function used here 22 | static inline struct TexturedMaterial **func_80077B24_inline_0(struct TexturedMaterial **table) { 23 | return &table[D_800AC2D8]; 24 | } 25 | 26 | void func_80077B24(UNUSED s32 arg0, s32 arg1) { 27 | struct MaterialGfx *materialGfx; 28 | struct TexturedMaterial *materialData; 29 | struct TexturedMaterial **materialPtr; 30 | s32 index; 31 | 32 | if (D_800AC2D8 < ARRAY_LEN(D_800AC1C8) && ((D_800AC2D8 < 0x3A) || (D_800ABCD8 < 4))) { 33 | // Some of these temps are not real and are instead probably symptoms of more inline functions being used 34 | materialGfx = &materialTable[arg1]; 35 | materialPtr = func_80077B24_inline_0(D_800AC1C8); 36 | 37 | materialData = get_material_data(materialGfx); 38 | 39 | index = D_800AC2D8; 40 | *materialPtr = materialData; 41 | D_800AC2D8 = index + 1; 42 | } 43 | } 44 | 45 | void func_80078170(void*, s32); 46 | 47 | void func_80077BD0(s32 *arg0) 48 | { 49 | arg0[4] = -1; 50 | func_80078170(arg0, 0); 51 | } 52 | 53 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_308", func_80077BF8); 54 | 55 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_308", func_80077C6C); 56 | 57 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_308", func_80077CCC); 58 | 59 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_308", func_80077F0C); 60 | 61 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_31.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_31", func_80026720); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_311.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_311", func_80078170); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_311", func_80078244); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_32.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_32", func_800268B0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_320.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_320", func_8007B7A0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_321.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_321", func_8007B850); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_321", func_8007B884); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_322.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_322", func_8007BA10); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_322", func_8007BC24); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_322", func_8007BF84); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_322", func_8007C1C0); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_322", func_8007C2BC); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_322", func_8007C3F4); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_322", func_8007C52C); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_322", func_8007C67C); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_324.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_324", func_8007CA50); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_325.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_325", func_8007CB60); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_325", func_8007CC78); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_325", func_8007CCD8); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_326.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_326", func_8007CDA0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_327.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007CDE0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007CE28); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007CFB8); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007D154); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007D280); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007D3B0); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007D69C); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007D6E8); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007D984); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007D9DC); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007DA04); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007DD08); 28 | 29 | const float D_8001D23C = -FLT_MAX; 30 | const float D_8001D240 = FLT_MAX; 31 | 32 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007DD98); 33 | 34 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007DEF8); 35 | 36 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_327", func_8007DFDC); 37 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_33.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_33", func_80026900); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_33", func_8002693C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_33", func_80026978); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_33", func_80026A08); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_33", func_80026B58); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_33", func_80026D78); 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_330.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_330", func_8007E0D0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_330", func_8007E17C); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_331.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_331", func_8007E1C0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_331", func_8007E2A8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_331", func_8007E688); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_331", func_8007E854); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_331", func_8007E904); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_331", func_8007EBA8); 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_332.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "gfx.h" 4 | 5 | extern s32 D_8009F098; 6 | extern s32 D_8009F170; 7 | extern s32 D_800A5874; 8 | 9 | void func_800914A8(float); 10 | void func_80095440(s32, s32, s32, s32); 11 | void func_8007F1F4(struct unkD_8009F094* arg0); 12 | void func_8007F368(struct unkD_8009F094* arg0, u32 arg1); 13 | void func_80039C34(void* arg0); 14 | void update_gfx_context(); 15 | void clear_depth_buffer(); 16 | void schedule_gfx_task(); 17 | void func_80037E60(void *, s32); 18 | void func_80099F18(s32, f32); 19 | void func_8003B298(void*); 20 | void func_8008B594(s32, void*); 21 | void func_80046D58(); 22 | void func_8003B358(void*); 23 | void func_8008B694(s32, void*); 24 | void func_80075ABC(); 25 | 26 | void func_8007F1D0() 27 | { 28 | func_8007F1F4(&D_8009F094); 29 | } 30 | 31 | void func_8007F1F4(struct unkD_8009F094* arg0) { 32 | func_80039C34(arg0 + 1); 33 | func_8007F368(arg0, 0); 34 | } 35 | 36 | void func_8007F22C(struct unkD_8009F094* arg0) { 37 | f32 temp_f20; 38 | struct unkD_8009F094_inner* temp_a0; 39 | struct unkD_8009F094_inner* temp_a0_2; 40 | 41 | temp_a0 = arg0->unk0; 42 | temp_f20 = D_8009FE10.unk4; 43 | if ((temp_a0 != NULL) && (D_8009F170 != 0)) { 44 | func_80099F18((s32) temp_a0, temp_f20); 45 | func_80037E60(&D_8009FE10, 2); 46 | temp_f20 = D_8009FE10.unk4; 47 | } 48 | update_gfx_context(); 49 | if (arg0->unk0 != NULL) { 50 | func_8003B298(&D_8009F098); 51 | func_8008B594((s32) arg0->unk0, &D_8009F098); 52 | } 53 | func_80046D58(); 54 | if (arg0->unk0 != NULL) { 55 | func_8003B358(&D_8009F098); 56 | clear_depth_buffer(); 57 | func_8008B694((s32) arg0->unk0, &D_8009F098); 58 | } else { 59 | draw_rectangle(0x40, 0, 0x40, 0xFF, 0x12, 0xE, 0x12D, 0xE1); 60 | } 61 | func_80075ABC(); 62 | schedule_gfx_task(); 63 | temp_a0_2 = arg0->unk0; 64 | if (temp_a0_2 != NULL) { 65 | func_80099F18((s32) temp_a0_2, temp_f20); 66 | } 67 | } 68 | 69 | void func_8007F368(struct unkD_8009F094* arg0, u32 arg1) 70 | { 71 | D_8009FE10.unk0 = arg1 < 1; 72 | } 73 | 74 | void func_8007F378() { 75 | func_800914A8(0.0f); 76 | func_80095440(0, D_800A5874, -1, -1); 77 | } 78 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_333.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_333", func_8007F3C0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_333", func_8007F404); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_333", func_8007F494); 10 | 11 | s32* func_8007F524(s32 **arg0) 12 | { 13 | s32* ret = arg0[2]; 14 | if (ret) 15 | { 16 | arg0[2] = (s32*)*ret; 17 | } 18 | return ret; 19 | } 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_334.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | s32* func_8007F540(s32 **arg0) 5 | { 6 | s32* ret = arg0[2]; 7 | if (ret) 8 | { 9 | arg0[2] = (s32*)*ret; 10 | } 11 | return ret; 12 | } 13 | 14 | void func_8007F55C(s32 *arg0, s32 *arg1) 15 | { 16 | if (arg1) 17 | { 18 | arg1[0] = arg0[2]; 19 | arg0[2] = (s32)arg1; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_335.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_8007F580); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_8007F660); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_8007F96C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_8007FB7C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_8007FFB0); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_80080038); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_800800F0); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_80080144); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_800801C0); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_80080438); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_80080500); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_80080684); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_335", func_8008080C); 30 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_34.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_34", func_80026DD0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_34", func_80026FB4); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_341.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_341", func_80080E80); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_341", func_80081334); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_341", func_80081370); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_341", func_80081494); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_341", func_8008151C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_341", func_80081634); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_341", func_800816A4); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_341", func_80081728); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_343.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | void obj_setter_velocity(struct GameObject *obj, Vec3f velocity); 7 | void func_80026D78(void*, struct GameObject*, s32); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_343", func_800818D0); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_343", func_800819FC); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_343", func_80081B10); 14 | 15 | void func_80081CA0(struct GameObject* obj, Vec3f velocity) { 16 | Vec3f sp10; 17 | s32 phi_v0; 18 | 19 | obj_setter_velocity(obj, velocity); 20 | 21 | VEC3F_SUB(sp10, velocity, obj->velocity); 22 | 23 | phi_v0 = 0; 24 | if (!(fabsf(sp10[0]) < 0.02f && fabsf(sp10[1]) < 0.02f && fabsf(sp10[2]) < 0.02f)) { 25 | phi_v0 = 1; 26 | } 27 | if (phi_v0 != 0) { 28 | func_80026D78(obj->unkC, obj, 2); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_346.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_80081D60); 6 | 7 | struct unkfunc_80081E20 { 8 | u8 padding[0x64]; 9 | void (*unk64)(struct unkfunc_80081E20 **, s32 *); 10 | }; 11 | 12 | void func_80081E20(struct unkfunc_80081E20 **arg0, s32 arg1, s32 arg2, s32 arg3) 13 | { 14 | s32 var[3]; 15 | var[0] = arg1; 16 | var[1] = arg2; 17 | var[2] = arg3; 18 | 19 | (*arg0)->unk64(arg0, var); 20 | } 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_80081E54); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_80081F04); 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_80081FB8); 27 | 28 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_8008208C); 29 | 30 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_80082414); 31 | 32 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_800824A0); 33 | 34 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_80082838); 35 | 36 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_800829B0); 37 | 38 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_80082A78); 39 | 40 | void func_80082DD8(void) { 41 | 42 | } 43 | 44 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_80082DE0); 45 | 46 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_346", func_8008302C); 47 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_35.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_80027090); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_80027124); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_8002716C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_800271DC); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_80027308); 14 | 15 | extern f32 D_8009FE14; 16 | 17 | void func_800273D4(f32 *arg0, f32 arg1) 18 | { 19 | arg0[0x8D] = D_8009FE14 + arg1; 20 | } 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_800273EC); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_800279F8); 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_80027B38); 27 | 28 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_80027BC4); 29 | 30 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_35", func_80027BFC); 31 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_351.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | u32 func_800830C0(u32 *arg0) 5 | { 6 | return (~arg0[0x70]) >> 0x1F; 7 | } 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_36.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_36", func_80027DB0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_365.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | void func_800849E0(void) { 6 | 7 | } 8 | 9 | 10 | void func_800849E8(void) { 11 | 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_366.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | void func_800849F0(void) { 6 | 7 | } 8 | 9 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_367.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_367", func_80084A00); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_367", func_80084A88); 8 | 9 | // Can play the enter vehicle and exit vehicle sounds 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_367", func_80084AC4); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_367", func_80084E14); 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_367", func_80085028); 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_367", func_80085094); 17 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_368.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | struct unkfunc_8008530C { 6 | u8 padding[0x268]; 7 | u32 unk268; 8 | }; 9 | 10 | void func_80085094(u32*); 11 | void func_80084A88(u32*); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_368", func_80085220); 14 | 15 | void func_800852EC(struct unkfunc_8008530C *arg0) 16 | { 17 | func_80085094(&arg0->unk268); 18 | } 19 | 20 | void func_8008530C(struct unkfunc_8008530C *arg0) 21 | { 22 | func_80084A88(&arg0->unk268); 23 | } 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_368", func_8008532C); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_368", func_8008546C); 28 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_369.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_369", func_800854F0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_37.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_37", func_80027EF0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_37", func_80028048); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_37", func_800281B4); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_371.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | void read_vec3f(u8 **dataPtrPtr, Vec3f arg1) 7 | { 8 | int i; 9 | *dataPtrPtr = ALIGN_PTR(*dataPtrPtr, 4); 10 | for (i = 0; i < 3; i++) 11 | { 12 | arg1[i] = READ_VALUE(dataPtrPtr, f32); 13 | } 14 | } 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_371", func_80085D94); 17 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_372.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_372", func_80085E90); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_372", func_800861A8); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_373.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | extern struct MaterialGfx *materialTable; 6 | 7 | Gfx *func_800922C4(struct MaterialGfx *, s32); 8 | 9 | void func_80086310(void *arg0, s32 arg1, Gfx *arg2) 10 | { 11 | if (arg1 != -1) 12 | { 13 | struct MaterialGfx *tmp = &materialTable[arg1]; 14 | Gfx *g = tmp->gfx; 15 | if (g == 0) 16 | { 17 | g = func_800922C4(tmp, 0); 18 | } 19 | gSPDisplayList(arg2, g); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_38.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80028460); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_8002853C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_800288D0); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80028A2C); 12 | 13 | void func_80028A84(s32 **arg0) 14 | { 15 | arg0[0xAB] = (s32*)arg0[3][0x38]; // TODO probably a struct 16 | } 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80028A94); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80028B3C); 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80028BC8); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80028D34); 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_800290A4); 27 | 28 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80029188); 29 | 30 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_800293E8); 31 | 32 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80029784); 33 | 34 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80029898); 35 | 36 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80029A9C); 37 | 38 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80029C28); 39 | 40 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80029D94); 41 | 42 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_38", func_80029F9C); 43 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_382.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_382", func_8008BED0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_383.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_383", func_8008BF70); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_383", func_8008BFC4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_383", func_8008C0AC); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_383", func_8008C148); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_384.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_384", func_8008C590); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_384", func_8008CA1C); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_385.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_8008CB60 { 5 | u8 padding[0x34]; 6 | u32 unk34; 7 | }; 8 | 9 | void func_8008CB60(struct unkfunc_8008CB60 *arg0, s32 arg1) 10 | { 11 | arg0->unk34 = arg1; 12 | } 13 | 14 | // TODO are these really the same struct? 15 | void func_8008CB68(struct unkfunc_8008CB60 *arg0) 16 | { 17 | arg0->unk34 = 0; 18 | } 19 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_386.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_386", func_8008CB70); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_387.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_387", func_8008CBE0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_387", func_8008CC1C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_387", func_8008CC64); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_388.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008CCA0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008CCE8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008CD78); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008CE0C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008CE9C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008CEF4); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008CFB4); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008D0BC); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008D0F8); 22 | 23 | // TODO types 24 | void func_8008D18C(s32 *arg0, s32 **arg1) 25 | { 26 | arg0[2] = (s32)*arg1; 27 | arg0[3] = 0; 28 | if (*arg1) 29 | { 30 | (*arg1)[3] = (s32)arg0; 31 | } 32 | *arg1 = arg0; 33 | } 34 | 35 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008D1AC); 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_388", func_8008D20C); 38 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_389.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_389", func_8008D260); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_389", func_8008D3A4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_389", func_8008D3EC); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_389", func_8008D434); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_390.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_390", func_8008D5C0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_391.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_391", func_8008D9D0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_392.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_392", func_8008DB80); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_393.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_393", func_8008EF60); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_393", func_8008F024); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_393", func_8008F0D4); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_393", func_8008F18C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_393", func_8008F348); 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_394.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_394", func_8008F690); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_40.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_40", func_8002A2E0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_40", func_8002A564); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_404.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void func_80091BFC(struct unkfunc_80091F54*); 6 | 7 | extern s32 D_800A3190; 8 | 9 | extern struct unkfunc_80091F54 *D_800AF310; 10 | extern s32 D_800AF320; 11 | 12 | extern s32 D_800AF44C[4]; 13 | extern s32 D_800AF45C[33]; 14 | extern s32 D_800AF4E0; 15 | 16 | void func_80091F40(struct unkfunc_80091F54 *arg0, s32 arg1) 17 | { 18 | arg0->unk318[arg1] = 1; 19 | } 20 | 21 | void func_80091F54(s32 arg0) 22 | { 23 | struct unkfunc_80091F54 var; 24 | u32 i; 25 | 26 | if (D_800AF320 != 1) 27 | { 28 | arg0 = 0; 29 | } 30 | 31 | if (arg0 != D_800AF4E0) 32 | { 33 | if (D_800AF310) 34 | { 35 | if (arg0) 36 | { 37 | bzero(&var, sizeof(var)); 38 | 39 | var.unk0 = &D_800A3190; 40 | 41 | for (i = 0; i < 4; i++) 42 | { 43 | var.unk18[D_800AF44C[i]] = 1; 44 | } 45 | 46 | i = 0; 47 | while (1) 48 | { 49 | if (i >= 0x21) 50 | break; 51 | var.unk318[D_800AF45C[i++]] = 1; 52 | } 53 | 54 | func_80091BFC(&var); 55 | } 56 | else 57 | { 58 | func_80091BFC(D_800AF310); 59 | } 60 | } 61 | D_800AF4E0 = arg0; 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_407.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_407", func_800942E0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_408.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_408", func_80094380); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_408", func_800943B0); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_408", func_80094404); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_408", func_8009452C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_408", func_80094574); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_408", func_800946A4); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_408", func_8009476C); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_408", func_80094B88); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_41.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_41", func_8002A690); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_41", func_8002A728); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_410.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_410", func_80094C50); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_410", func_80094DDC); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_410", func_80095038); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_410", func_800950B8); 12 | 13 | struct unkfunc_80095138 { 14 | u8 padding[0x234]; 15 | s32 unk234[0x04]; 16 | s32 unk244; 17 | s32 unk248[0x04]; 18 | s32 unk258; 19 | }; 20 | 21 | void func_80095138(struct unkfunc_80095138 *arg0, s32 arg1) 22 | { 23 | arg0->unk234[arg0->unk244++] = arg1; 24 | } 25 | 26 | void func_80095154(struct unkfunc_80095138 *arg0, s32 arg1) 27 | { 28 | arg0->unk248[arg0->unk258++] = arg1; 29 | } 30 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_411.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern s32 D_800F6A68; 5 | 6 | void func_80094C50(s32, s32); 7 | 8 | void func_80095170(s32 arg0, s32 arg1) 9 | { 10 | if (arg1 == 1) 11 | { 12 | func_80094C50(D_800F6A68, 1); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_412.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_412", func_800951A0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_412", func_800951FC); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_413.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_413", func_80095240); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_413", func_800952D4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_413", func_8009532C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_413", func_80095364); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_413", func_800953D4); 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_414.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_414", func_80095440); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_414", func_800954FC); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_415.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_415", func_800958A0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_416.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_416", func_80095930); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_416", func_80095A08); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_416", func_80095A48); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_416", func_80095B54); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_417.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_80095D70 { 5 | u8 padding[0x264]; 6 | s32 unk264; 7 | }; 8 | 9 | void func_80096290(); 10 | 11 | void func_80095D70(struct unkfunc_80095D70 *arg0, s32 arg1) 12 | { 13 | arg0->unk264 = arg1; 14 | } 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_80095D78); 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_80095DB0); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_80095DF4); 21 | 22 | void func_80095E64() 23 | { 24 | func_80096290(); 25 | } 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_80095E84); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_80096058); 30 | 31 | INCLUDE_ASM(void, "rocket/codeseg2/codeseg2_417", func_80096290); 32 | 33 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_800962D4); 34 | 35 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_8009631C); 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_80096388); 38 | 39 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_80096444); 40 | 41 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_417", func_800966C8); 42 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_42.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_42", func_8002A780); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_42", func_8002A7B4); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_42", func_8002A86C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_42", func_8002AA78); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_42", func_8002AAD0); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_42", func_8002AC5C); 16 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_420.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_420", func_80096820); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_420", func_800968FC); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_421.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_421", func_80096C40); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_421", func_80096CE8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_421", func_80096E7C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_421", func_80096F84); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_422.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_80097010 { 5 | u8 padding[0x4C]; 6 | s32 unk4C; 7 | }; 8 | 9 | s32 func_80097010(struct unkfunc_80097010 *arg0) 10 | { 11 | return arg0->unk4C + 2; 12 | } 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_422", func_8009701C); 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_422", func_800970B8); 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_422", func_80097134); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_422", func_80097404); 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_422", func_80097438); 23 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_423.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_423", func_800974E0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_424.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_424", func_800976D0); 7 | 8 | struct unkfunc_8009778C { 9 | u8 padding[0x7C]; 10 | f32 unk7C; 11 | u32 unk80; 12 | u32 unk84; 13 | u32 unk88; 14 | f32 unk8C; 15 | u32 unk90; 16 | u32 unk94; 17 | f32 unk98; 18 | }; 19 | 20 | void func_8009778C(struct unkfunc_8009778C *arg0, Vec3f arg1) 21 | { 22 | arg0->unk7C = arg1[0]; 23 | arg0->unk8C = arg1[1]; 24 | arg0->unk98 = arg1[2]; 25 | } 26 | 27 | struct unkfunc_800977A8 { 28 | u8 padding[0x62]; 29 | s8 unk62; 30 | }; 31 | 32 | void func_800977A8(struct unkfunc_800977A8 *arg0) 33 | { 34 | arg0->unk62 = 0; 35 | } 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_424", func_800977B0); 38 | 39 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_424", func_80097D7C); 40 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_426.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_426", func_800987B0); 6 | 7 | void func_800987FC(s32 arg0, s32 *arg1) 8 | { 9 | arg1[0x09] = 1; // TODO probably a struct 10 | } 11 | 12 | void func_80098808(s32 arg0, s32 *arg1) 13 | { 14 | arg1[0x09] = 0; // TODO probably a struct 15 | arg1[0x16] = 0; 16 | } 17 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_427.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | // regalloc 6 | #ifdef NON_MATCHING 7 | void decompress(struct DecompressionParams *arg0, u32 compressedSize, u8 *src, u32 uncompressedSize, u8 *dst) 8 | { 9 | s32 uVar5; 10 | u8 *srcEnd; 11 | u8 *dstEnd; 12 | u8 layoutBits; 13 | 14 | srcEnd = src + compressedSize; 15 | dstEnd = dst + uncompressedSize; 16 | while (1) 17 | { 18 | if (src >= srcEnd) 19 | return; 20 | uVar5 = 7; 21 | layoutBits = *src++; 22 | while (1) 23 | { 24 | if (uVar5 < 0) 25 | { 26 | break; 27 | } 28 | if (src >= srcEnd) 29 | { 30 | return; 31 | } 32 | if (dst >= dstEnd) 33 | { 34 | break; 35 | } 36 | if ((u32)layoutBits & (1U << (uVar5))) 37 | { 38 | s32 firstByte = *src++; 39 | s32 secondByte = *src++; 40 | u16 bytes = firstByte << 8 | secondByte; 41 | u8 *curByte; 42 | u8 *lastByte; 43 | u16 offset = (bytes >> arg0->shift); 44 | u16 length = (bytes & arg0->mask) + arg0->lengthOffset - 1; 45 | curByte = dst - offset; 46 | lastByte = curByte + length; 47 | while (lastByte > curByte) 48 | { 49 | *dst++ = *curByte++; 50 | } 51 | } 52 | else 53 | { 54 | *dst++ = *src++; 55 | } 56 | uVar5 = uVar5 - 1; 57 | } 58 | uVar5 = 7; 59 | } 60 | } 61 | #else 62 | INCLUDE_ASM(void, "rocket/codeseg2/codeseg2_427", decompress, struct DecompressionParams *, u32, u8 *, u32, u8 *); 63 | #endif 64 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_428.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_428", func_80098900); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_429.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | f32 clampf_abs(f32 val, f32 absMax) 5 | { 6 | f32 ret = val; 7 | if (val > absMax) 8 | { 9 | ret = absMax; 10 | } 11 | else if (val < -absMax) 12 | { 13 | ret = -absMax; 14 | } 15 | return ret; 16 | } 17 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_430.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_430", func_800989C0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_430", func_80098AE0); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_432.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_432", func_80098C10); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_432", func_80098E68); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_432", func_80098ED4); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_432", func_80098F28); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_432", func_80098F54); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_432", func_80098F94); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_432", func_8009904C); 18 | 19 | f32 sinf(f32); 20 | 21 | f32 func_8009911C(f32 arg0) { 22 | return sinf(arg0); 23 | } 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_432", func_8009913C); 26 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_433.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | extern f32 sinf(f32); 6 | 7 | void sincosf(f32 angle, f32 *sinOut, f32 *cosOut) 8 | { 9 | f32 sinVal; 10 | f64 cosVal; 11 | s32 num_half_rotations; 12 | 13 | sinVal = sinf(angle); 14 | *sinOut = sinVal; 15 | cosVal = sqrtf(1.0 - sinVal * sinVal); 16 | num_half_rotations = (s32)(0.5 + fabsf(angle) / (float)M_PI); 17 | 18 | if (num_half_rotations & 1) { 19 | *cosOut = -cosVal; 20 | } else { 21 | *cosOut = cosVal; 22 | } 23 | } 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_80099264); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_800992F4); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_80099408); 30 | 31 | f32 func_800995D8(f32 x) 32 | { 33 | return -sinf(x); 34 | } 35 | 36 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_800995F8); 37 | 38 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_800997BC); 39 | 40 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_8009990C); 41 | 42 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_800999D4); 43 | 44 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_80099A34); 45 | 46 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_80099A9C); 47 | 48 | // Returns the a % b, wrapping around to positive when the result is negative. 49 | // Does not work with a negative b value. 50 | f32 positive_fmodf(f32 a, f32 b) { 51 | s32 integer_quotient; 52 | f32 remainder; 53 | 54 | integer_quotient = a / b; 55 | remainder = a - integer_quotient * b; 56 | 57 | if ((a < 0.0f && remainder > 0.0f)) { 58 | // This is pointless due to the last if statement 59 | remainder -= b; 60 | } else if (a > 0.0f && remainder < 0.0f) { 61 | remainder += b; 62 | } 63 | 64 | if (remainder < 0.0f) { 65 | remainder += b; 66 | } 67 | 68 | return remainder; 69 | } 70 | 71 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_433", func_80099B8C); 72 | 73 | s32 func_80099BCC(f32 *arg0, f32 arg1) 74 | { 75 | return arg0[0] < arg1 && arg1 < arg0[1]; 76 | } 77 | 78 | // asm(".include \"src/rocket/codeseg2/codeseg2_433_rodata.s\""); 79 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_434.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | f32 func_80099C00(f32 *arg0, f32 arg1) 5 | { 6 | if (arg0[0] > arg1) 7 | { 8 | return arg0[0]; 9 | } 10 | else if (arg1 > arg0[1]) 11 | { 12 | return arg0[1]; 13 | } 14 | else 15 | { 16 | return arg1; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_435.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_435", func_80099C40); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_435", func_80099D78); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_435", func_80099F18); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_435", func_8009A264); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_435", func_8009A464); 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_436.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_436", func_8009A4F0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_436", func_8009A674); 8 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_437.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_437", func_8009A7C0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_438.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | extern Vec3f D_800AF794; 7 | 8 | void set_vec3f_zero(Vec3f vec) 9 | { 10 | VEC3F_COPY(vec, D_800AF794); 11 | } 12 | 13 | void set_vec3f_scalar(Vec3f vec, f32 val) 14 | { 15 | vec[0] = vec[1] = vec[2] = val; 16 | } 17 | 18 | void set_vec3f_components(Vec3f vec, f32 x, f32 y, f32 z) 19 | { 20 | vec[0] = x; 21 | vec[1] = y; 22 | vec[2] = z; 23 | } 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_438", func_8009A85C); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_438", func_8009A8C4); 28 | 29 | f32 vec3f_magnitude(Vec3f vec) 30 | { 31 | f32 x2 = vec[0] * vec[0]; 32 | f32 y2 = vec[1] * vec[1]; 33 | f32 z2 = vec[2] * vec[2]; 34 | return sqrtf(x2 + y2 + z2); 35 | } 36 | 37 | f32 vec3f_normalize(Vec3f vec) 38 | { 39 | s32 i = 0; 40 | f32 x2 = vec[0] * vec[0]; 41 | f32 y2 = vec[1] * vec[1]; 42 | f32 z2 = vec[2] * vec[2]; 43 | f32 mag = sqrtf(x2 + y2 + z2); 44 | 45 | for (; i < 3; i++) 46 | { 47 | vec[i] /= mag; 48 | } 49 | 50 | return mag; 51 | } 52 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_44.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_8002B434 { 5 | u8 padding[0x268]; 6 | u32 unk268; 7 | }; 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002ACA0); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002AD8C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002ADE4); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002AF64); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002B124); 18 | 19 | // This is getting a booster pack 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002B1BC); 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002B2F4); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002B384); 25 | 26 | void func_80085094(u32*); 27 | 28 | void func_8002B434(struct unkfunc_8002B434 *arg0) 29 | { 30 | func_80085094(&arg0->unk268); 31 | } 32 | 33 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002B454); 34 | 35 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_44", func_8002B4A0); 36 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_442.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_442", func_8009B7F0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_443.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_443", func_8009BBB0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_443", func_8009BD60); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_443", func_8009BDAC); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_443", func_8009BEB0); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_443", func_8009C02C); 14 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_446.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_446", func_8009C0E0); 7 | 8 | void func_8009C28C(struct unkfunc_8009C28C *arg0, s32 arg1) 9 | { 10 | arg0->unk250[arg0->unk24C++] = arg1; 11 | } 12 | 13 | void func_8009C2A8(struct unkfunc_8009C28C *arg0, s32 arg1) 14 | { 15 | arg0->unk274[arg0->unk270++] = arg1; 16 | } 17 | 18 | void func_8009C2C4(struct unkfunc_8009C28C *arg0, s32 arg1) 19 | { 20 | arg0->unk298[arg0->unk294++] = arg1; 21 | } 22 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_447.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void func_8009C2E0(struct unkfunc_8009C28C *arg0, s32 arg1) 6 | { 7 | arg0->unk2BC[arg0->unk2B8++] = arg1; 8 | } 9 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_448.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "codeseg2.h" 4 | 5 | void func_80050868(struct unkfunc_8001DFD0 *arg0, void* arg1, void* arg2); 6 | 7 | void func_8009C300(struct unkfunc_8001DFD0 *arg0, void **arg1, void* arg2) 8 | { 9 | func_80050868(arg0, arg1, arg2); 10 | arg1[81] = arg0; // might be a struct 11 | } 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_448", func_8009C338); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_448", func_8009C4C8); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_448", func_8009C5C8); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_448", func_8009C6D8); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_449.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009C730); 7 | 8 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009C7C4); 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009C8DC); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009CDBC); 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009CEF8); 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009CFF4); 17 | 18 | struct unkfunc_8009D61C { 19 | u8 padding[0xA4]; 20 | void (*unkA4)(struct unkfunc_8009D61C **, s32); 21 | }; 22 | 23 | void func_8009D61C(s32 arg0, struct unkfunc_8009D61C ***arg1) 24 | { 25 | (*arg1[1])->unkA4(arg1[1], arg0); 26 | } 27 | 28 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009D64C); 29 | 30 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009D764); 31 | 32 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009D84C); 33 | 34 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009D898); 35 | 36 | extern struct MaterialGfx *materialTable; 37 | 38 | Gfx *func_800922C4(struct MaterialGfx *, s32); 39 | void func_80086310(struct unkfunc_800338D0 *arg0, s32 arg1, Gfx *arg2); 40 | 41 | void func_8009DA54(struct unkfunc_800338D0 *arg0, s32 arg1, Gfx* arg2) 42 | { 43 | if (arg0->unk26D == 0 && arg0->unk258.gfx == 0) 44 | { 45 | arg0->unk258.materialData.raw = materialTable[arg1].materialData.raw; 46 | gSPDisplayList(arg2, func_800922C4(&arg0->unk258, 1)); 47 | } 48 | else 49 | { 50 | func_80086310(arg0, arg1, arg2); 51 | } 52 | } 53 | 54 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_449", func_8009DAD0); 55 | 56 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_451.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void func_80050E24(s32, s32, s32*); 5 | 6 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_451", func_8009DC20); 7 | 8 | struct unkfunc_8009DC84 { 9 | u8 padding[0x26C]; 10 | s8 unk26C; 11 | }; 12 | 13 | void func_8009DC84(struct unkfunc_8009DC84 *arg0) 14 | { 15 | arg0->unk26C = 0; 16 | } 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_451", func_8009DC8C); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_451", func_8009DD38); 21 | 22 | extern s32 D_800AF838; 23 | 24 | void func_8009DE1C(s32 arg0) 25 | { 26 | func_80050E24(arg0, 1, &D_800AF838); 27 | } 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_451", func_8009DE44); 30 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_452.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009DEA0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009DEF8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009DF9C); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009E05C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009E13C); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009E1B0); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009E5EC); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009E6D4); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009E7CC); 22 | 23 | extern struct { 24 | f32 unk0; 25 | } D_8009FE14; 26 | 27 | struct unkfunc_8009E84C { 28 | u8 padding[0x18]; 29 | s32 unk18; 30 | f32 unk1C; 31 | }; 32 | 33 | void func_8009E84C(struct unkfunc_8009E84C *arg0, s32 arg1) 34 | { 35 | if (arg1 != arg0->unk18) 36 | { 37 | arg0->unk18 = arg1; 38 | arg0->unk1C = D_8009FE14.unk0; 39 | } 40 | } 41 | 42 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009E86C); 43 | 44 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009E9B4); 45 | 46 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009EA40); 47 | 48 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009EC94); 49 | 50 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009EDC8); 51 | 52 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_452", func_8009EE60); 53 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_46.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002B5A0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002B604); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002B734); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002B78C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002B7D4); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002BA34); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002BB84); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002BFE4); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C064); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C0A0); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C0E0); 26 | 27 | struct unkfunc_8002C154 { 28 | u8 padding[0x230]; 29 | u32 unk230; 30 | f32 unk234; 31 | }; 32 | 33 | extern struct { 34 | f32 unk0; 35 | } D_8009FE14; 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C120); 38 | 39 | void func_8002C154(struct unkfunc_8002C154 *arg0, u32 arg1) 40 | { 41 | if (arg1 != arg0->unk230) 42 | { 43 | arg0->unk230 = arg1; 44 | arg0->unk234 = D_8009FE14.unk0; 45 | } 46 | } 47 | 48 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C174); 49 | 50 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C25C); 51 | 52 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C320); 53 | 54 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C390); 55 | 56 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C468); 57 | 58 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C4F0); 59 | 60 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C63C); 61 | 62 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002C77C); 63 | 64 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002CC44); 65 | 66 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_46", func_8002CCCC); 67 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_53.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_53", func_8002CFA0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_53", func_8002D050); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_53", func_8002D42C); 10 | 11 | void func_8002D678(s32 arg0, s32 (*arg1)[3], s32 arg2, s32 arg3, s32 arg4) 12 | { 13 | s32 i; 14 | for (i = 0; i < arg0; i++) 15 | { 16 | arg1[i][0] = arg4 + (arg1[i][0] - arg3); 17 | } 18 | } 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_53", func_8002D6AC); 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_53", func_8002D724); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_53", func_8002D7A0); 25 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_61.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_61", func_8002E6F0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_62.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_62", func_8002E790); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_63.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_63", func_8002E8A0); 7 | 8 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_63", func_8002E980); 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_63", func_8002EAD8); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_63", func_8002EB48); 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_63", func_8002EF54); 15 | 16 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_63", func_8002F044); 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_63", func_8002F0C0); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_63", func_8002F60C); 21 | 22 | void func_8002F674(struct unkfunc_8009C28C *arg0, s32 arg1) 23 | { 24 | arg0->unk3AC[arg0->unk3A8++] = arg1; 25 | } 26 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_66.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_8002FB6C { 5 | u8 padding[0x270]; 6 | u32 unk270; 7 | }; 8 | 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_66", func_8002F690); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_66", func_8002F724); 13 | 14 | void func_80085094(u32*); 15 | void func_80084A88(u32*); 16 | 17 | void func_8002FB6C(struct unkfunc_8002FB6C *arg0) 18 | { 19 | func_80085094(&arg0->unk270); 20 | } 21 | 22 | void func_8002FB8C(struct unkfunc_8002FB6C *arg0) 23 | { 24 | func_80084A88(&arg0->unk270); 25 | } 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_66", func_8002FBAC); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_66", func_8002FC2C); 30 | 31 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_66", func_8002FC9C); 32 | 33 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_66", func_8002FDB4); 34 | 35 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_66", func_8002FDF8); 36 | 37 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_66", func_800303FC); 38 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_67.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_800305C0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_8003068C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_800306F8); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_800307E8); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_80030804); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_80030874); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_80030944); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_80030C0C); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_67", func_80030F48); 22 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_68.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void func_80085094(s32); 5 | void func_80084A88(s32); 6 | 7 | 8 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_68", func_80031340); 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_68", func_8003149C); 11 | 12 | void func_8003173C(s32 arg0) 13 | { 14 | func_80085094(arg0 + 0x2A8); 15 | } 16 | 17 | void func_8003175C(s32 arg0) 18 | { 19 | func_80084A88(arg0 + 0x2A8); 20 | } 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_68", func_8003177C); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_68", func_80031BAC); 25 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_69.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_69", func_80031DC0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_69", func_80031E6C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_69", func_80031EEC); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_69", func_80031F28); 12 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_70.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_70", func_80031F60); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_71.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "macros.h" 4 | 5 | void func_80085094(s32*); 6 | void func_80084A88(s32*); 7 | 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80031FB0); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_8003202C); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80032454); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_800324A8); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80032564); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_800325D8); 20 | 21 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_8003269C); 22 | 23 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80032974); 24 | 25 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80032A20); 26 | 27 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80032C74); 28 | 29 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80032E24); 30 | 31 | const u32 D_8001A8FC = 0xFF0000FF; 32 | const u32 D_8001A900 = 0xFFFFFFFF; 33 | 34 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80033468); 35 | 36 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_800338B0); 37 | 38 | struct unkfunc_800338D0 { 39 | u8 padding[0x258]; 40 | s32 unk258; 41 | }; 42 | 43 | void func_800338D0(s32 arg0, struct unkfunc_800338D0 *arg1) 44 | { 45 | arg1->unk258 = 0; 46 | } 47 | 48 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_800338D8); 49 | 50 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80033958); 51 | 52 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80033A24); 53 | 54 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80033FFC); 55 | 56 | struct unkfunc_80034124 { 57 | u8 padding[0x2C8]; 58 | s32 unk2C8; 59 | }; 60 | 61 | void func_80034124(struct unkfunc_80034124 *arg0) 62 | { 63 | func_80085094(&arg0->unk2C8); 64 | } 65 | 66 | void func_80034144(struct unkfunc_80034124 *arg0) 67 | { 68 | func_80084A88(&arg0->unk2C8); 69 | } 70 | 71 | struct unkfunc_80034164 { 72 | u8 padding[0x278]; 73 | s32 unk278; 74 | }; 75 | 76 | void func_80034164(struct unkfunc_80034164 *arg0) 77 | { 78 | func_80085094(&arg0->unk278); 79 | } 80 | 81 | void func_80034184(struct unkfunc_80034164 *arg0) 82 | { 83 | func_80084A88(&arg0->unk278); 84 | } 85 | 86 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_800341A4); 87 | 88 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_71", func_80034294); 89 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_75.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_75", func_800344C0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_75", func_8003451C); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_75", func_80034664); 10 | 11 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_75", func_800346C8); 12 | 13 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_75", func_80034774); 14 | 15 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_75", func_80034808); 16 | 17 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_75", func_8003483C); 18 | 19 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_75", func_800348E8); 20 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_76.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_76", func_80034A00); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_76", func_800352E8); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_76", func_80035370); 10 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_78.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_78", func_80035540); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_79.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_79", func_800355E0); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_80.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_80", func_80035680); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_81.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_800356F0 { 5 | s32 unk0; 6 | s32 unk4; 7 | }; 8 | 9 | void func_800356F0(struct unkfunc_800356F0 *arg0, s32 arg1) 10 | { 11 | arg0->unk4 = arg1; 12 | } 13 | 14 | void func_800356F8(s32 *arg0, s32 arg1) 15 | { 16 | arg0[2] = arg1; 17 | if (arg1 == 3) 18 | { 19 | arg0[4] = 0; 20 | arg0[5] = 0; 21 | } 22 | } 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_81", func_80035714); 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_81", func_800357B8); 27 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_88.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_88", func_80037E60); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_89.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct unkfunc_80037EC0 { 5 | s32 unk0; 6 | s32 unk4; 7 | }; 8 | 9 | void func_8004EC70(); 10 | 11 | void func_80037EC0(struct unkfunc_80037EC0 *arg0, s32 arg1) 12 | { 13 | arg0->unk4 = arg1; 14 | } 15 | 16 | void func_80037EC8(s32 *arg0, s32 arg1) 17 | { 18 | *arg0 = arg1; 19 | if (arg1 == 0) 20 | { 21 | func_8004EC70(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_90.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "types.h" 4 | 5 | struct unkfunc_80037EF0 { 6 | u8 pad[0x3A8]; 7 | s32 unk3A8; 8 | }; 9 | 10 | void func_800875E8(struct GameObject *arg0, u32 romAddr, u8 *dataPtr); 11 | 12 | void func_80037EF0(struct unkfunc_80037EF0 *arg0, u32 romAddr, u8 *dataPtr) 13 | { 14 | arg0->unk3A8 = -1; 15 | func_800875E8((struct GameObject*) arg0, romAddr, dataPtr); 16 | } 17 | 18 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_90", func_80037F14); 19 | 20 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_90", func_80038104); 21 | 22 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_90", func_800382B0); 23 | 24 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_90", func_80038468); 25 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_92.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | void func_8004BB64(u32*); 6 | void func_8004C44C(u32*); 7 | 8 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_92", func_80038630); 9 | 10 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_92", func_800387E8); 11 | 12 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_92", func_80038DC4); 13 | 14 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_92", func_800390BC); 15 | 16 | struct unkfunc_8003918C { 17 | u8 padding[0x254]; 18 | u32 unk254; 19 | }; 20 | 21 | void func_8003918C(struct unkfunc_8003918C *arg0) 22 | { 23 | func_8004BB64(&arg0->unk254); 24 | } 25 | 26 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_92", func_800391AC); 27 | 28 | void func_800391EC(struct unkfunc_8003918C *arg0) 29 | { 30 | func_8004C44C(&arg0->unk254); 31 | } 32 | 33 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_92", func_8003920C); 34 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_93.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_93", func_80039260); 6 | -------------------------------------------------------------------------------- /src/rocket/codeseg2/codeseg2_94.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_94", func_800392B0); 6 | 7 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_94", func_80039360); 8 | 9 | INCLUDE_ASM(s32, "rocket/codeseg2/codeseg2_94", func_80039378); 10 | -------------------------------------------------------------------------------- /tools/psyq-obj-parser: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RocketRet/Rocket-Robot-On-Wheels/cd1fc6d3f575841a240373d7b8a2baf532da2f9f/tools/psyq-obj-parser -------------------------------------------------------------------------------- /tools/regnum_to_names.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python3 2 | 3 | import sys 4 | from pathlib import Path 5 | 6 | regnames = [ 7 | "zero", # 0 8 | 9 | "at", # 1 10 | 11 | "v0", # 2 12 | "v1", # 3 13 | 14 | "a0", # 4 15 | "a1", # 5 16 | "a2", # 6 17 | "a3", # 7 18 | 19 | "t0", # 8 20 | "t1", # 9 21 | "t2", # 10 22 | "t3", # 11 23 | "t4", # 12 24 | "t5", # 13 25 | "t6", # 14 26 | "t7", # 15 27 | 28 | "s0", # 16 29 | "s1", # 17 30 | "s2", # 18 31 | "s3", # 19 32 | "s4", # 20 33 | "s5", # 21 34 | "s6", # 22 35 | "s7", # 23 36 | 37 | "t8", # 24 38 | "t9", # 25 39 | 40 | "k0", # 26 41 | "k1", # 27 42 | 43 | "gp", # 28 44 | "sp", # 29 45 | "fp", # 30 46 | "ra", # 31 47 | ] 48 | 49 | if len(sys.argv) < 2: 50 | print(f"Usage: {sys.argv[0]} [function name]") 51 | sys.exit(0) 52 | 53 | func_name = sys.argv[1] 54 | output_path = "out.s" 55 | 56 | found_files = list(Path("asm/nonmatchings").rglob(f"{func_name}.s")) 57 | 58 | if len(found_files) == 0: 59 | print(f"Could not find function {func_name}") 60 | sys.exit(1) 61 | 62 | input_path = found_files[0] 63 | 64 | with open(input_path, "r") as file: 65 | filedata = file.read() 66 | 67 | for i in reversed(range(len(regnames))): 68 | filedata = filedata.replace(f"${i}", f"${regnames[i]}") 69 | 70 | with open(output_path, "w") as file: 71 | file.write(filedata) 72 | 73 | -------------------------------------------------------------------------------- /tools/reloc_addrs.txt: -------------------------------------------------------------------------------- 1 | rom:0x001010 symbol:_codesegs0_1SegmentBssEnd reloc:MIPS_HI16 2 | rom:0x001014 symbol:_codesegs0_1SegmentBssEnd reloc:MIPS_LO16 3 | -------------------------------------------------------------------------------- /tools/rename_function.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | SYM_ADDRS="tools/symbol_addrs.txt" 4 | 5 | if [ "$#" -ne 4 ]; then 6 | echo "usage: $0 [source dir] [containing source file] [old function name] [new function name]" 7 | echo "e.g.: $0 codeseg1 initialize.c func_80007E80 osInitialize" 8 | exit 0 9 | fi 10 | 11 | SRC_BASE=$(echo "$2" | cut -f 1 -d '.') 12 | 13 | grep -Fq $3 src/rocket/$1/$2 14 | GREP_RET=$? 15 | if [ $GREP_RET -eq 2 ]; then 16 | echo "Invalid parameters" 17 | exit 1 18 | elif [ $GREP_RET -eq 1 ]; then 19 | echo "Function $3 not in file src/rocket/$1/$2" 20 | exit 1 21 | fi 22 | 23 | if [[ $3 =~ func_[0-9A-F]{8} ]]; then 24 | echo "Adding entry for function $4 to $SYM_ADDRS" 25 | echo "$4 = 0x${3:5:8}; // !" >> $SYM_ADDRS 26 | fi 27 | 28 | grep -rl "$3" tools/symbol_addrs.txt | xargs sed -i "s/$3/$4/g" 29 | grep -rl "$3" src | xargs sed -i "s/$3/$4/g" 30 | grep -rl "$3" asm | xargs sed -i "s/$3/$4/g" 31 | grep -rl "$3" build/us/src | xargs sed -i "s/$3/$4/g" 32 | grep -rl "$3" build/us/asm | xargs sed -i "s/$3/$4/g" 33 | 34 | if [ -f "asm/nonmatchings/$1/$SRC_BASE/$3.s" ]; then 35 | echo "Renaming nonmatching func file: asm/nonmatchings/$1/$SRC_BASE/$3.s to asm/nonmatchings/$1/$SRC_BASE/$4.s" 36 | mv "asm/nonmatchings/$1/$SRC_BASE/$3.s" "asm/nonmatchings/$1/$SRC_BASE/$4.s" 37 | fi 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /tools/rocket-tools/.gitignore: -------------------------------------------------------------------------------- 1 | extract_texture 2 | extract_mesh 3 | archive 4 | -------------------------------------------------------------------------------- /tools/rocket-tools/Makefile: -------------------------------------------------------------------------------- 1 | CPPFLAGS := -I.. 2 | CFLAGS := -O3 3 | CC := gcc 4 | 5 | PROGRAMS := extract_texture archive 6 | 7 | all: $(PROGRAMS) 8 | clean: 9 | rm -f $(PROGRAMS) 10 | 11 | extract_texture: extract_texture.c librocket.c librocket.h ../n64graphics.c ../n64graphics.h ../utils.c ../utils.h 12 | archive: archive.cpp librocket.c librocket.h lib/fmtlib/src/format.cc bswap.h 13 | archive: CC := g++-9 14 | archive: CFLAGS += -std=c++2a 15 | archive: CPPFLAGS += -Ilib/fmtlib/include 16 | 17 | $(PROGRAMS): % : 18 | $(CC) $(CFLAGS) $(CPPFLAGS) $(filter %.c,$^) $(filter %.cc,$^) $(filter %.cpp,$^) -o $@ 19 | 20 | .PHONY: all clean 21 | -------------------------------------------------------------------------------- /tools/rocket-tools/extract_all.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import os 3 | 4 | if __name__ == "__main__": 5 | for i in range(1944): 6 | call_string = "./extract_texture ../../baserom.us.z64 %d /mnt/c/n64/rrow_textures/rrow_asset_%d.png" % (i, i) 7 | os.system(call_string) -------------------------------------------------------------------------------- /tools/rocket-tools/librocket.h: -------------------------------------------------------------------------------- 1 | #ifndef __ROCKET_H__ 2 | #define __ROCKET_H__ 3 | 4 | #include 5 | #include 6 | 7 | #define ROCKET_ROM_SIZE 0xC00000 8 | 9 | #define ROM_CONTENT_START 0xB0460 10 | #define ASSET_TABLE_ADDR 0x2F3F2A 11 | #define ASSET_TABLE_LEN 0x798 12 | 13 | struct TextureHeader { 14 | uint16_t width; 15 | uint16_t height; 16 | uint8_t imSize; // G_IM_SIZ_x 17 | uint8_t imFormat; // G_IM_FMT_x 18 | uint16_t bytesPerRow; 19 | uint32_t imageBytes; 20 | uint16_t paletteBytes; 21 | uint16_t unkE; 22 | }; 23 | 24 | struct Texture { 25 | struct TextureHeader header; 26 | void *imageData; 27 | void *paletteData; 28 | }; 29 | 30 | struct TextureCompressionHeader { 31 | uint8_t handlerIndex; 32 | uint8_t compressionParams; 33 | uint8_t unk2; 34 | uint8_t unk3; 35 | uint32_t compressedLength; 36 | }; 37 | 38 | struct DecompressionParams { 39 | uint32_t lengthOffset; 40 | uint32_t negativeShift; 41 | uint32_t shift; 42 | uint32_t mask; 43 | }; 44 | 45 | extern struct DecompressionParams decompressionParamsTable[2]; 46 | int compress(struct DecompressionParams *params, uint32_t decompressedSize, uint8_t *src, uint8_t **dst, int lookahead); 47 | void decompress(struct DecompressionParams *params, uint32_t compressedSize, uint8_t *src, uint32_t uncompressedSize, uint8_t *dst); 48 | unsigned int get_texture_address(FILE *romFile, unsigned int assetIndex); 49 | void read_texture_headers(FILE *romFile, struct Texture *asset, struct TextureCompressionHeader *handlerHeader, unsigned int assetIndex); 50 | void read_texture(void *data, void *data2, FILE *romFile, unsigned int assetIndex); 51 | void swap_words(void *data, unsigned int numBytes, unsigned int bytesPerRow); 52 | void flip_rows(void *data, unsigned int height, unsigned int bytesPerRow); 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /tools/undefined_syms.txt: -------------------------------------------------------------------------------- 1 | sinf = __sinf; 2 | cosf = __cosf; 3 | osTvType = 0x80000300; 4 | osRomBase = 0x80000308; 5 | osResetType = 0x8000030C; 6 | osAppNMIBuffer = 0x8000031C; 7 | 8 | D_80000000 = 0x80000000; 9 | D_A0000000 = 0xA0000000; 10 | 11 | D_A4040010 = 0xA4040010; 12 | D_A4300000 = 0xA4300000; 13 | D_A4300008 = 0xA4300008; 14 | D_A430000C = 0xA430000C; 15 | D_A4400010 = 0xA4400010; 16 | D_A450000C = 0xA450000C; 17 | D_A4600010 = 0xA4600010; 18 | D_A4800018 = 0xA4800018; 19 | 20 | D_B00B0464 = _assetsSegmentRomStart + 4; 21 | _assetsSegmentRomStart = assets_ROM_START + 0xB0000000; 22 | _wavebankRomStart = wavebank_ROM_START + 0xB0000000; 23 | gspF3DEX2_fifoTextStart = _binary_bin_f3dex2_code_bin_start; 24 | gspF3DEX2_fifoDataStart = _binary_bin_f3dex2_data_bin_start; 25 | n_aspMainTextStart = _binary_bin_n_aspMain_code_bin_start; 26 | n_aspMainDataStart = _binary_bin_n_aspMain_data_bin_start; 27 | rspbootTextStart = _binary_bin_rspboot_code_bin_start; 28 | rspbootTextEnd = _binary_bin_rspboot_code_bin_end; 29 | _codesegs0_1SegmentBssStart = codesegs0_1_bss_BSS_START; 30 | _codesegs0_1SegmentBssEnd = codesegs0_1_bss_BSS_END; 31 | _codeseg2SegmentBssStart = codeseg2_bss_BSS_START; 32 | _codeseg2SegmentBssEnd = codeseg2_bss_BSS_END; 33 | D_800F6ADF = _codeseg2SegmentBssEnd + 63; 34 | --------------------------------------------------------------------------------