falso
/
perfect_dark
mirror of https://github.com/n64decomp/perfect_dark.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove rmon, crash, fault, videbug and debughud

This commit is contained in:
Ryan Dwyer 2022-11-11 23:18:45 +10:00
parent 64155bcb15
commit 40c4dd9130
24 changed files with 5 additions and 1858 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ld/libfiles.ntsc-final.inc
View File

@ -32,8 +32,6 @@
build/ROMID/lib/audiodma.o (section); \
build/ROMID/lib/profile.o (section); \
build/ROMID/lib/vi.o (section); \
build/ROMID/lib/fault.o (section); \
build/ROMID/lib/crash.o (section); \
build/ROMID/lib/dma.o (section); \
build/ROMID/lib/main.o (section); \
build/ROMID/lib/snd.o (section); \
@ -45,8 +43,6 @@
build/ROMID/lib/str.o (section); \
build/ROMID/lib/ultra/libc/sprintf.o (section); \
build/ROMID/lib/pimgr.o (section); \
build/ROMID/lib/videbug.o (section); \
build/ROMID/lib/debughud.o (section); \
build/ROMID/lib/base.o (section); \
build/ROMID/lib/joy.o (section); \
build/ROMID/lib/lib_15850.o (section); \
@ -62,7 +58,6 @@
build/ROMID/lib/collision.o (section); \
build/ROMID/lib/lib_2f490.o (section); \
build/ROMID/lib/rdp.o (section); \
build/ROMID/lib/rmon.o (section); \
build/ROMID/lib/ultra/audio/heap.o (section); \
build/ROMID/lib/naudio/n_sl.o (section); \
build/ROMID/lib/lib_2fc60.o (section); \

1
src/game/bossfile.c
View File

@ -15,7 +15,6 @@
#include "game/options.h"
#include "game/utils.h"
#include "bss.h"
#include "lib/fault.h"
#include "lib/snd.h"
#include "data.h"
#include "types.h"

1
src/game/filelist.c
View File

@ -15,7 +15,6 @@
#include "game/options.h"
#include "game/utils.h"
#include "bss.h"
#include "lib/fault.h"
#include "lib/joy.h"
#include "lib/snd.h"
#include "lib/mema.h"

1
src/game/gamefile.c
View File

@ -14,7 +14,6 @@
#include "game/options.h"
#include "game/utils.h"
#include "bss.h"
#include "lib/fault.h"
#include "lib/snd.h"
#include "lib/str.h"
#include "data.h"

1
src/game/title.c
View File

@ -19,7 +19,6 @@
#include "game/propobj.h"
#include "game/savebuffer.h"
#include "bss.h"
#include "lib/crash.h"
#include "lib/joy.h"
#include "lib/vi.h"
#include "lib/main.h"

1
src/game/vmstats.c
View File

@ -1,7 +1,6 @@
#include <ultra64.h>
#include "constants.h"
#include "bss.h"
#include "lib/debughud.h"
#include "lib/vm.h"
#include "data.h"
#include "types.h"

4
src/include/constants.h
View File

@ -3906,12 +3906,12 @@ enum rspevent {
#define SQUADRON_0E 0x0e
#define SQUADRON_0F 0x0f
#define STACKSIZE_RMON 0x40
#define STACKSIZE_RMON 0
#define STACKSIZE_IDLE 0x40
#define STACKSIZE_SCHED 0x400
#define STACKSIZE_MAIN 0x9800
#define STACKSIZE_AUDIO 0x1000
#define STACKSIZE_FAULT 0x40
#define STACKSIZE_FAULT 0
#define STACKSIZE_RESET 0x100
#define STACK_START (0x80400000 \

113
src/include/lib/crash.h
View File

@ -1,113 +0,0 @@
#ifndef _IN_LIB_CRASH_H
#define _IN_LIB_CRASH_H
#include <ultra64.h>
#include "data.h"
#include "types.h"
extern const char var70052700[];
extern const char var70052704[];
extern const char var70052708[];
extern const char var7005270c[];
extern const char var70052710[];
extern const char var70052714[];
extern const char var70052718[];
extern const char var7005271c[];
extern const char var70052720[];
extern const char var70052724[];
extern const char var70052728[];
extern const char var70052730[];
extern const char var70052738[];
extern const char var70052744[];
extern const char var70052770[];
extern const char var70052788[];
extern const char var700527b4[];
extern const char var700527dc[];
extern const char var700527e4[];
extern const char var700527e8[];
extern const char var70052800[];
extern const char var70052810[];
extern const char var7005281c[];
extern const char var70052824[];
extern const char var70052854[];
extern const char var70052864[];
extern const char var70052870[];
extern const char var700528a0[];
extern const char var700528a4[];
extern const char var700528a8[];
extern const char var700528ac[];
extern const char var700528b0[];
extern const char var700528b4[];
extern const char var700528b8[];
extern const char var700528bc[];
extern const char var700528c0[];
extern const char var700528c4[];
extern const char var700528c8[];
extern const char var700528cc[];
extern const char var700528d0[];
extern const char var700528d4[];
extern const char var700528d8[];
extern const char var700528dc[];
extern const char var700528e0[];
extern const char var700528e4[];
extern const char var700528e8[];
extern const char var700528ec[];
extern const char var700528f0[];
extern const char var700528f4[];
extern const char var700528f8[];
extern const char var700528fc[];
extern const char var70052900[];
extern const char var70052904[];
extern const char var70052908[];
extern const char var7005290c[];
extern const char var70052910[];
extern const char var70052914[];
extern const char var70052918[];
extern const char var7005291c[];
extern const char var70052920[];
extern const char var70052924[];
extern const char var70052928[];
extern const char var70052938[];
extern const char var70052944[];
extern const char var70052950[];
extern const char var7005295c[];
extern const char var70052968[];
extern const char var70052974[];
extern const char var70052978[];
extern const char var7005297c[];
extern const char var70052980[];
extern const char var70052984[];
extern const char var70052988[];
extern const char var7005298c[];
extern const char var70052990[];
extern const char var70052994[];
extern const char var70052998[];
extern const char var7005299c[];
extern const char var700529a0[];
extern const char var700529a4[];
extern const char var700529a8[];
extern const char var700529ac[];
#if VERSION == VERSION_NTSC_BETA
extern u8 g_CrashHasMessage;
#else
extern bool g_CrashHasMessage;
#endif
void crashSetMessage(char *string);
void crashCreateThread(void);
u32 crashGetParentStackFrame(u32 *ptr, u32 *start, u32 sp, u32 *regs);
bool crashIsReturnAddress(u32 *instruction);
u32 crashGetStackEnd(u32 sp, s32 tid);
u32 crashGetStackStart(u32 arg0, s32 tid);
bool crashIsDouble(f32 value);
void crashPrintFloat(s32 index, f32 arg1);
void crashPrint2Floats(s32 index, f32 value1, f32 value2);
void crashPrint3Floats(s32 index, f32 value1, f32 value2, f32 value3);
void crashPutChar(s32 x, s32 y, char c);
void crashAppendChar(char c);
void crashScroll(s32 numlines);
void crashRenderChar(s32 x, s32 y, char c);
void crashReset(void);
void crashRenderFrame(u16 *fb);
#endif

18
src/include/lib/debughud.h
View File

@ -1,18 +0,0 @@
#ifndef _IN_LIB_DEBUGHUD_H
#define _IN_LIB_DEBUGHUD_H
#include <ultra64.h>
#include "data.h"
#include "types.h"
void dhudPutCharAt(s32 x, s32 y, char c);
void dhudInit(void);
void dhudReset(void);
void dhudClear(void);
void dhudSetPos(s32 x, s32 y);
void dhudSetFgColour(s32 r, s32 g, s32 b, s32 a);
void dhudSetBgColour(s32 r, s32 g, s32 b, s32 a);
void dhudPrintChar(u8 c);
void dhudPrintString(char *text);
Gfx *dhudRender(Gfx *gdl);
#endif

10
src/include/lib/fault.h
View File

@ -1,10 +0,0 @@
#ifndef _IN_LIB_FAULT_H
#define _IN_LIB_FAULT_H
#include <ultra64.h>
#include "data.h"
#include "types.h"
void faultInit(void);
void faultAssert(char *msg, char *file, s32 line);
#endif

14
src/include/lib/rmon.h
View File

@ -1,14 +0,0 @@
#ifndef _IN_LIB_RMON_H
#define _IN_LIB_RMON_H
#include <ultra64.h>
#include "data.h"
#include "types.h"
void rmonproc();
void rmon0002fa30(u32 *arg0, s32 arg1);
void rmon0002fa38(s32 arg0);
void rmon0002fa40(void);
bool rmonIsDisabled(void);
void rmonPrintf(const char *format, ...);
#endif

10
src/include/lib/videbug.h
View File

@ -1,10 +0,0 @@
#ifndef _IN_LIB_VIDEBUG_H
#define _IN_LIB_VIDEBUG_H
#include <ultra64.h>
#include "data.h"
#include "types.h"
void videbugCreate(void);
void videbugInit(void);
#endif

10
src/lib/args.c
View File

@ -3,7 +3,6 @@
#include "bss.h"
#include "lib/args.h"
#include "lib/str.h"
#include "lib/rmon.h"
#include "string.h"
#include "data.h"
#include "types.h"
@ -71,14 +70,7 @@ bool argsParseDebugArgs(void)
devaddr = 0x1ffff00;
if (rmonIsDisabled()) {
g_ArgBuffer[0] = 0;
} else {
for (i = 0; i < 30; i++) {
osPiReadIo(devaddr, &g_ArgBuffer[i]);
devaddr += 4;
}
}
g_ArgBuffer[0] = 0;
argParseString((char *) g_ArgBuffer);

5
src/lib/boot.c
View File

@ -8,17 +8,13 @@
#include "bss.h"
#include "lib/args.h"
#include "lib/rzip.h"
#include "lib/crash.h"
#include "lib/main.h"
#include "lib/snd.h"
#include "lib/pimgr.h"
#include "lib/videbug.h"
#include "lib/rmon.h"
#include "lib/lib_48150.h"
#include "data.h"
#include "types.h"
OSThread g_RmonThread;
OSThread g_IdleThread;
OSThread g_MainThread;
OSThread g_SchedThread;
@ -214,7 +210,6 @@ void bootCreateSchedThread(void)
void bootPhase2(void *arg)
{
bootCreateIdleThread();
videbugCreate();
pimgrCreate();
if (argsParseDebugArgs()) {

1054
src/lib/crash.c
View File

File diff suppressed because it is too large Load Diff

425
src/lib/debughud.c
View File

@ -1,425 +0,0 @@
#include <ultra64.h>
#include "constants.h"
#include "bss.h"
#include "lib/debughud.h"
#include "game/gfxmemory.h"
#include "data.h"
#include "types.h"
// The number of columns and rows in the screen buffer, in characters.
#define NUM_COLS 80
#define NUM_ROWS 35
// The dimensions of each character's texture, in pixels.
// These are shown at 4x the texture size when rendering.
#define CHAR_W 4
#define CHAR_H 7
#define MAX_COLOURS 32
struct dhudchar {
char c;
u8 paletteindex;
};
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
struct dhudchar g_DHudCharBuffer[NUM_COLS][NUM_ROWS];
Gfx g_DHudFgGbi[MAX_COLOURS];
Gfx g_DHudBgGbi[MAX_COLOURS];
Gfx var800606e0nb = gsSPEndDisplayList();
// This is a 128 x 21 sprite of characers in greyscale at one byte per pixel.
// Each character is 4 x 7 pixels. There's 3 rows with 32 characters per row.
u32 g_DHudSprite[] = {
// space ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
0x00000000, 0x00227a00, 0x007a348b, 0x00223434, 0x00115811, 0x00696900, 0x00000000, 0x00009c00, 0x00004600, 0x00460000, 0x00004600, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000046, 0x00229c11, 0x00346900, 0x00229c11, 0x00699c11, 0x00005834, 0x00adad34, 0x00118b34, 0x009cad7a, 0x00229c11, 0x00229c11, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00113411,
0x00000000, 0x0046ce00, 0x00ad58de, 0x00466969, 0x009c9c69, 0x008b8b00, 0x00469c00, 0x0022ce00, 0x00583400, 0x00345800, 0x007ace69, 0x00005800, 0x00000000, 0x00000000, 0x00000000, 0x00003446, 0x008b007a, 0x00588b00, 0x008b008b, 0x0022007a, 0x00119c69, 0x008b0000, 0x009c1100, 0x0022008b, 0x008b007a, 0x008b007a, 0x00000000, 0x00000000, 0x00225869, 0x00000000, 0x69582200, 0x009c698b,
0x00000000, 0x0046ce00, 0x00222258, 0x00deef7a, 0x00ad1111, 0x0069ef9c, 0x008b0000, 0x00460000, 0x008b0000, 0x00008b00, 0x0058ce34, 0x00008b00, 0x00000000, 0x00000000, 0x00000000, 0x00008b00, 0x008b008b, 0x00008b00, 0x0011007a, 0x00118b46, 0x0058467a, 0x00cead22, 0x009c8b00, 0x0000117a, 0x00698b46, 0x008b00ad, 0x0034ad00, 0x0034ad00, 0x228b4600, 0x8b8b8b8b, 0x00468b22, 0x0011008b,
0x00000000, 0x00007a00, 0x00000000, 0x009c9c00, 0x00118b34, 0x22adbd46, 0x008b8b34, 0x00000000, 0x008b0000, 0x00008b00, 0x007a2269, 0x22adef9c, 0x00000000, 0x22adadad, 0x00000000, 0x00226900, 0x008b008b, 0x00008b00, 0x00007a00, 0x0000117a, 0x009c347a, 0x0000008b, 0x00ce117a, 0x00002269, 0x008b227a, 0x00229c8b, 0x00001100, 0x00001100, 0xad580000, 0x34343434, 0x000058ad, 0x0000bd34,
0x00000000, 0x00112200, 0x00000000, 0x22dede22, 0x00ce5858, 0x0046468b, 0x008bad00, 0x00000000, 0x008b0000, 0x00008b00, 0x00000000, 0x00008b00, 0x00003400, 0x00000000, 0x00002200, 0x00691100, 0x008b008b, 0x00008b00, 0x00691158, 0x0011008b, 0x007a9cad, 0x1122008b, 0x008b008b, 0x00008b00, 0x008b008b, 0x0000227a, 0x00002200, 0x00002200, 0x228b4600, 0x8b8b8b8b, 0x00468b22, 0x00006900,
0x00000000, 0x00228b00, 0x00000000, 0x008b8b00, 0x0034bd00, 0x00119c46, 0x007a6969, 0x00000000, 0x00583400, 0x00345800, 0x00000000, 0x00005800, 0x0011ff00, 0x00000000, 0x00228b00, 0x008b0000, 0x00349c22, 0x008bce69, 0x22bdad8b, 0x007a9c11, 0x00008b8b, 0x118b9c11, 0x00349c22, 0x00005800, 0x00349c11, 0x00588b11, 0x00228b00, 0x0069ad00, 0x00225869, 0x00000000, 0x69582200, 0x0000bd00,
0x00000000, 0x00000000, 0x00000000, 0x00464600, 0x00004600, 0x00000000, 0x00000000, 0x00000000, 0x00004600, 0x00460000, 0x00000000, 0x00000000, 0x00583400, 0x00000000, 0x00000000, 0x58340000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x008b0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
// @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _
0x00229c11, 0x00221100, 0x11223400, 0x00003411, 0x11342200, 0x00343422, 0x00343422, 0x00002222, 0x00220022, 0x00342222, 0x00003434, 0x00341122, 0x22341100, 0x11110022, 0x22221134, 0x00002200, 0x00343411, 0x00003400, 0x00343411, 0x00113411, 0x00343434, 0x11341134, 0x11220034, 0x34220034, 0x11340022, 0x11220034, 0x00223422, 0x00008b34, 0x00460000, 0x00587a00, 0x00005800, 0x00000000,
0x348b008b, 0x0069bd00, 0x11de7a58, 0x00ad69de, 0x22ce7a9c, 0x11ce7aad, 0x11ce7aad, 0x00ad7ade, 0x22ce00ce, 0x0069ce58, 0x00008bce, 0x22ce22ce, 0x46ce4600, 0x7abd00ff, 0x58ff46ce, 0x00ad7a9c, 0x11ce7a7a, 0x00ad7a8b, 0x22ce7a7a, 0x118b7abd, 0x469ccece, 0x8b8b34ce, 0x8b8b00bd, 0xbd8b22bd, 0x58ce00ce, 0x22bd00ce, 0x00bd7aad, 0x00008b00, 0x007a1100, 0x00008b00, 0x00694658, 0x00000000,
0x468b7abd, 0x00588b22, 0x008b008b, 0x46460011, 0x008b007a, 0x118b3458, 0x008b3458, 0x46460011, 0x008b008b, 0x00008b00, 0x0000117a, 0x008b7a11, 0x008b0000, 0x589c58bd, 0x11ad698b, 0x4646007a, 0x118b007a, 0x5846007a, 0x118b007a, 0x46580011, 0x34228b46, 0x6934008b, 0x007a008b, 0x58348b7a, 0x11696946, 0x00695846, 0x00113458, 0x00008b00, 0x00116900, 0x00008b00, 0x00110011, 0x00000000,
0x468b8b9c, 0x009c228b, 0x00dead7a, 0x58340000, 0x008b007a, 0x11dead00, 0x00dead00, 0x583400ad, 0x46deadbd, 0x00008b00, 0x3411117a, 0x00dead00, 0x008b0000, 0x5846ad7a, 0x118b8b8b, 0x5834007a, 0x11dead34, 0x5834007a, 0x11dede46, 0x0058ad34, 0x00008b00, 0x5834008b, 0x008b117a, 0x00bdde8b, 0x0022ad00, 0x0011bd00, 0x00226900, 0x00008b00, 0x00008b00, 0x00008b00, 0x00000000, 0x00000000,
0x348b348b, 0x469c8bad, 0x008b007a, 0x347a0058, 0x008b009c, 0x008b008b, 0x008b0000, 0x228b007a, 0x008b008b, 0x00008b00, 0x46462269, 0x008b117a, 0x008b007a, 0x6934347a, 0x118b34de, 0x118b009c, 0x008b0000, 0x228b009c, 0x008b117a, 0x3434008b, 0x00008b00, 0x4646008b, 0x0022ce00, 0x00adbd8b, 0x008b007a, 0x00008b00, 0x008b0058, 0x00008b00, 0x00003446, 0x00008b00, 0x00000000, 0x00000000,
0x00697a9c, 0x7a9c00bd, 0x69cead58, 0x0058ad58, 0x22bdad34, 0x22cead8b, 0x22bd2200, 0x0058ad58, 0x22ad00ce, 0x008bbd7a, 0x007a7a00, 0x22bd228b, 0x69bdadbd, 0x8b9c00bd, 0x69ce227a, 0x0058ad34, 0x22ce6900, 0x009cef69, 0x22bd2258, 0x7a9c9c22, 0x0046ce34, 0x007aad11, 0x00005800, 0x00580058, 0x22ad00ce, 0x0058bd34, 0x00ad9c9c, 0x00008b00, 0x0000008b, 0x00008b00, 0x00000000, 0x22222222,
0x00002211, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0058588b, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000ce34, 0x0000007a, 0x1158ad00, 0x00000000, 0x7a7a7a7a,
// ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~ blank/unused
0x00693400, 0x00000000, 0x22690000, 0x00000000, 0x0000008b, 0x00000000, 0x0000589c, 0x11000000, 0x22690000, 0x00001100, 0x00001100, 0x22690000, 0x008b7a00, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00004646, 0x00004600, 0x00464600, 0x00000000, 0x00000000,
0x0046ad00, 0x00000000, 0x008b0000, 0x00000000, 0x0000008b, 0x00000000, 0x00116900, 0x00000000, 0x008b0000, 0x00006900, 0x00006900, 0x008b0000, 0x00008b00, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00226900, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00008b00, 0x00008b00, 0x00008b00, 0x00000000, 0x00000000,
0x00005800, 0x008b9c34, 0x00cead69, 0x007aad9c, 0x008badbd, 0x007aad34, 0x009cde7a, 0x008b9cce, 0x11cead69, 0x00589c00, 0x008bad69, 0x008bad69, 0x00008b00, 0x7aad9c9c, 0x22cead69, 0x007aad34, 0x22cead69, 0x008b9cde, 0x22de9c69, 0x007aad9c, 0x009cde7a, 0x118b00ad, 0x11ce00de, 0x34ce00de, 0x22ce34ad, 0x22ce00de, 0x00bd9cad, 0x00008b00, 0x00008b00, 0x00008b00, 0x229c347a, 0x00000000,
0x00000000, 0x009cad7a, 0x008b007a, 0x69340034, 0x4634009c, 0x46ce9cbd, 0x00226900, 0x4646008b, 0x008b008b, 0x00008b00, 0x0000007a, 0x00de7a00, 0x00008b00, 0x46468b69, 0x119c008b, 0x4646008b, 0x008b0069, 0x5846008b, 0x008b0000, 0x008b7a58, 0x00226900, 0x008b008b, 0x007a117a, 0x008b8b8b, 0x0058bd00, 0x008b008b, 0x00464646, 0x00467a00, 0x00008b00, 0x00008b46, 0x7a349c22, 0x00000000,
0x00000000, 0x4634227a, 0x009c007a, 0x58460022, 0x4646009c, 0x34460034, 0x00226900, 0x3446009c, 0x008b008b, 0x00008b00, 0x0000007a, 0x008b6911, 0x00008b00, 0x46468b69, 0x118b008b, 0x3458008b, 0x00ad0069, 0x584600ad, 0x008b0000, 0x0069348b, 0x00226911, 0x008b009c, 0x0011de00, 0x00adbd8b, 0x00699c11, 0x00469c34, 0x00225858, 0x00008b00, 0x00008b00, 0x00008b00, 0x00000000, 0x00000000,
0x00000000, 0x119c8bce, 0x22adad58, 0x007a9c46, 0x0069adad, 0x1169ad46, 0x008bbd7a, 0x0069adad, 0x22ad00bd, 0x118bce69, 0x0000007a, 0x227a34ce, 0x008bbd7a, 0x7a699c46, 0x69bd00ce, 0x007a9c22, 0x00bd9c58, 0x0069adad, 0x22ce9c34, 0x008bad58, 0x00009c8b, 0x00699cad, 0x11005800, 0x00580069, 0x11bd349c, 0x00009c00, 0x00adad9c, 0x00008b00, 0x00008b00, 0x00008b00, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000008b, 0x00000000, 0x00000000, 0x00004646, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x008b0000, 0x0000008b, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00226900, 0x00000000, 0x00008b46, 0x00008b00, 0x00467a00, 0x00000000, 0x00000000,
};
s32 g_DHudBaseX = 5;
s32 g_DHudBaseY = 1;
s32 g_DHudPosX = 24;
s32 g_DHudPosY = 16;
bool g_DHudIsEmpty = true;
bool g_DHudInitialised = false;
Gfx var80061180nb[] = {
gsDPPipeSync(),
gsDPSetCycleType(G_CYC_1CYCLE),
gsDPSetColorDither(G_CD_DISABLE),
gsDPSetRenderMode(IM_RD | CVG_DST_FULL | ZMODE_OPA | FORCE_BL | GBL_c1(G_BL_CLR_MEM, G_BL_A_IN, G_BL_CLR_IN, G_BL_1), IM_RD | CVG_DST_FULL | ZMODE_OPA | FORCE_BL | GBL_c2(G_BL_CLR_MEM, G_BL_A_IN, G_BL_CLR_IN, G_BL_1)),
gsDPSetCombineLERP(PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT),
gsDPSetTexturePersp(G_TP_NONE),
gsDPSetTextureLUT(G_TT_NONE),
gsDPSetAlphaCompare(G_AC_NONE),
gsDPLoadTextureBlock(g_DHudSprite, G_IM_FMT_IA, G_IM_SIZ_8b, 128, 21, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD),
gsDPLoadSync(),
gsSPEndDisplayList(),
};
struct dhudchar (*g_DHudCharBufferPtr)[NUM_ROWS] = NULL;
Gfx *g_DHudFgGbiPtrs = NULL;
Gfx *g_DHudBgGbiPtrs = NULL;
s32 g_DHudNextPaletteIndex = 0;
Gfx var80061218nb = gsSPEndDisplayList();
Gfx var80061220nb = gsDPNoOp();
Gfx g_DHudFgColour = gsDPSetPrimColor(0, 0, 0xff, 0xff, 0xff, 0);
Gfx g_DHudBgColour = gsDPSetEnvColor(0, 0, 0, 0);
#endif
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
s32 dhud00013fe0nb(s32 arg0, s32 arg1)
{
return 0;
}
#endif
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
s32 dhud00013ff0nb(s32 arg0, s32 arg1)
{
return 0;
}
#endif
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
void dhud00014000nb(void)
{
// empty
}
#endif
void dhudInit(void)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
s32 i;
s32 x;
s32 y;
u32 stack;
Gfx cmd = {0, 0};
g_DHudCharBufferPtr = g_DHudCharBuffer;
g_DHudFgGbiPtrs = g_DHudFgGbi;
g_DHudBgGbiPtrs = g_DHudBgGbi;
g_DHudInitialised = true;
for (x = 0; x < NUM_COLS; x++) {
for (y = 0; y < NUM_ROWS; y++) {
g_DHudCharBufferPtr[x][y].c = '\0';
g_DHudCharBufferPtr[x][y].paletteindex = 0;
}
}
for (i = 0; i < MAX_COLOURS; i++) {
g_DHudFgGbiPtrs[i] = cmd;
g_DHudBgGbiPtrs[i] = cmd;
}
#endif
}
void dhudReset(void)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
if (g_DHudInitialised) {
dhudClear();
}
#endif
}
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
void dhudPutCharAt(s32 x, s32 y, char c)
{
s32 i;
// Check if the current colour pair exists in the palette
for (i = 0; i < MAX_COLOURS; i++) {
if (g_DHudFgColour.words.w1 == g_DHudFgGbiPtrs[i].words.w1
&& g_DHudBgColour.words.w1 == g_DHudBgGbiPtrs[i].words.w1) {
goto havepalette;
}
}
// Add colours to pallete
g_DHudFgGbiPtrs[g_DHudNextPaletteIndex] = g_DHudFgColour;
g_DHudBgGbiPtrs[g_DHudNextPaletteIndex] = g_DHudBgColour;
i = g_DHudNextPaletteIndex = (g_DHudNextPaletteIndex + 1) % MAX_COLOURS;
havepalette:
g_DHudCharBufferPtr[x][y].c = c;
g_DHudCharBufferPtr[x][y].paletteindex = i;
if (c != '\0') {
g_DHudIsEmpty = false;
}
}
#endif
void dhudResetPos(void)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
if (g_DHudInitialised) {
g_DHudPosX = g_DHudBaseX;
g_DHudPosY = g_DHudBaseY;
}
#endif
}
void dhudClear(void)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
s32 x;
s32 y;
if (g_DHudInitialised && g_DHudIsEmpty != true) {
for (y = 0; y < NUM_ROWS; y++) {
for (x = 0; x < NUM_COLS; x++) {
dhudPutCharAt(x, y, '\0');
}
}
g_DHudIsEmpty = true;
dhudResetPos();
dhud00014000nb();
g_DHudNextPaletteIndex = 0;
}
#endif
}
void dhudSetPos(s32 x, s32 y)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
if (g_DHudInitialised) {
x += g_DHudBaseX;
y += g_DHudBaseY;
if (y >= (viGetHeight() - 10) / CHAR_H) {
y = (viGetHeight() - 10) / CHAR_H - 1;
}
g_DHudPosX = x;
g_DHudPosY = y;
}
#endif
}
void dhudSetFgColour(s32 r, s32 g, s32 b, s32 a)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
if (g_DHudInitialised) {
g_DHudFgColour.words.w1 = r << 24 | g << 16 | b << 8 | (255 - a);
}
#endif
}
void dhudSetBgColour(s32 r, s32 g, s32 b, s32 a)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
if (g_DHudInitialised) {
g_DHudBgColour.words.w1 = r << 24 | g << 16 | b << 8 | (255 - a);
}
#endif
}
void dhudPrintChar(u8 c)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
s32 maxwidth = (viGetWidth() - 13) / CHAR_W;
s32 maxheight = (viGetHeight() - 10) / CHAR_H;
if (g_DHudInitialised) {
if (c == '\0' || (c >= ' ' && c <= '~')) {
dhudPutCharAt(g_DHudPosX, g_DHudPosY, c);
}
g_DHudPosX++;
if (c == '\r' || c == '\n' || g_DHudPosX >= maxwidth) {
g_DHudPosX = g_DHudBaseX;
g_DHudPosY++;
if (g_DHudPosY >= maxheight) {
g_DHudPosY = g_DHudBaseY;
}
}
}
#endif
}
#if VERSION != VERSION_PAL_BETA
void dhudPrintCharAt(s32 x, s32 y, char c)
{
#if VERSION == VERSION_NTSC_BETA
if (g_DHudInitialised) {
dhudSetPos(x, y);
dhudPrintChar(c);
}
#endif
}
#endif
void dhudPrintString(char *str)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
if (g_DHudInitialised) {
while (*str != '\0') {
dhudPrintChar(*str++);
}
}
#endif
}
#if VERSION != VERSION_PAL_BETA
void dhudPrintStringAt(s32 x, s32 y, char *str)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
if (g_DHudInitialised) {
dhudSetPos(x, y);
while (*str != '\0') {
dhudPrintChar(*str++);
}
}
#endif
}
#endif
Gfx *dhudRender(Gfx *gdl)
{
#if VERSION == VERSION_NTSC_BETA || VERSION == VERSION_PAL_BETA
if (!g_DHudInitialised) {
return gdl;
}
if (!g_DHudIsEmpty) {
s32 x;
s32 y;
s32 appliedpaletteindex;
s32 available;
s32 needed;
Gfx *gdl2;
static u32 percentage = 255;
// Calculate how much space is needed in the display list
// based on the number of characters to draw and the number
// of times the colours will be changed.
gdl2 = gdl;
appliedpaletteindex = -1;
for (y = 0; y < NUM_ROWS; y++) {
for (x = 0; x < NUM_COLS; x++) {
u32 c = g_DHudCharBufferPtr[x][y].c;
s32 paletteindex = g_DHudCharBufferPtr[x][y].paletteindex;
if (c != '\0') {
if (paletteindex != appliedpaletteindex) {
gdl2 += 2;
appliedpaletteindex = paletteindex;
}
if (1);
gdl2 += 3;
}
}
}
// Make sure there'll be a least 256 GBI commands free (2KB)
available = gfxGetFreeGfx(gdl) - 256 * sizeof(Gfx);
needed = (u32)gdl2 - (u32)gdl;
if (needed <= 0) { // shouldn't be possible
return gdl;
}
{
s32 x;
s32 appliedpaletteindex = -1;
// Write a "percentage" (out of 255) into a global variable
// which shows how much of the displaylist will be committed,
// provided 2KB is kept free.
if (available <= 0) {
// There's already less than 2KB free in the display list
percentage = 0;
} else if (needed > available) {
// The display list would end with less than 2KB free,
// so calculate the percentage
percentage = available * 255 / needed;
} else {
// The display list would end with at least 2KB free,
// so the displaylist can be committed in full
percentage = 256;
}
gSPDisplayList(gdl++, var80061180nb);
// Build the display list for real this time.
// Regardless of the availability checks above, just stop when
// there's less than 1KB of free space... sort of. It still writes
// the colour change commands, but the debug HUD doesn't exactly
// draw rainbows so it's no big deal.
for (y = 0; y < NUM_ROWS; y++) {
for (x = 0; x < NUM_COLS; x++) {
u32 c = g_DHudCharBufferPtr[x][y].c;
s32 paletteindex = g_DHudCharBufferPtr[x][y].paletteindex;
if (c != '\0') {
if (paletteindex != appliedpaletteindex) {
*gdl = g_DHudFgGbiPtrs[paletteindex]; gdl++;
*gdl = g_DHudBgGbiPtrs[paletteindex]; gdl++;
appliedpaletteindex = paletteindex;
}
if (1);
if (gfxGetFreeGfx(gdl) >= 1024) {
gSPTextureRectangle(gdl++,
// Screen coords to draw at
x * CHAR_W * 4,
y * CHAR_H * 4,
x * CHAR_W * 4 + CHAR_W * 4,
y * CHAR_H * 4 + CHAR_H * 4,
0,
// Sprite X and Y positions
((c - ' ') % 32) * CHAR_W * 32,
((s32)(c - ' ') >> 5) * CHAR_H * 32,
1024, 1024);
}
}
}
}
}
}
#endif
return gdl;
}

16
src/lib/fault.c
View File

@ -1,16 +0,0 @@
#include <ultra64.h>
#include "constants.h"
#include "bss.h"
#include "lib/crash.h"
#include "lib/rmon.h"
#include "data.h"
#include "types.h"
void faultInit(void)
{
}
void faultAssert(char *message, char *file, s32 line)
{
rmonPrintf("ASSERTION : %s, %d: (\"%s\")\n", file, line, message);
}

12
src/lib/main.c
View File

@ -49,8 +49,6 @@
#include "lib/vm.h"
#include "lib/rzip.h"
#include "lib/vi.h"
#include "lib/fault.h"
#include "lib/crash.h"
#include "lib/dma.h"
#include "lib/joy.h"
#include "lib/main.h"
@ -58,13 +56,10 @@
#include "lib/memp.h"
#include "lib/mema.h"
#include "lib/profile.h"
#include "lib/videbug.h"
#include "lib/debughud.h"
#include "lib/anim.h"
#include "lib/rdp.h"
#include "lib/lib_34d0.h"
#include "lib/lib_2f490.h"
#include "lib/rmon.h"
#include "lib/rng.h"
#include "lib/str.h"
#include "data.h"
@ -198,9 +193,8 @@ void mainInit(void)
varsInit();
mempInit();
memaInit();
videbugInit();
viConfigureForLogos();
var8005d9b0 = rmonIsDisabled();
var8005d9b0 = 1;
joyInit();
osCreateMesgQueue(&queue, &msg, 1);
@ -366,7 +360,6 @@ void mainInit(void)
mempResetPool(MEMPOOL_8);
mempResetPool(MEMPOOL_PERMANENT);
crashReset();
challengesInit();
utilsInit();
func000034d0();
@ -375,7 +368,6 @@ void mainInit(void)
cheatsInit();
func0000e9c0();
textInit();
dhudInit();
playermgrInit();
frametimeInit();
stub0f00b200();
@ -575,7 +567,6 @@ void mainLoop(void)
gfxReset();
joyReset();
dhudReset();
mblurReset(g_StageNum);
lvReset(g_StageNum);
viReset(g_StageNum);
@ -638,7 +629,6 @@ void mainTick(void)
profileReset();
func000034d8();
joyDebugJoy();
schedSetCrashEnable2(false);
if (g_MainGameLogicEnabled) {
profileStart(PROFILEMARKER_CPU);

1
src/lib/mema.c
View File

@ -1,7 +1,6 @@
#include <ultra64.h>
#include "constants.h"
#include "bss.h"
#include "lib/debughud.h"
#include "lib/mema.h"
#include "lib/memp.h"
#include "data.h"

73
src/lib/rmon.c
View File

@ -1,73 +0,0 @@
#include <ultra64.h>
#include <stdarg.h>
#include "constants.h"
#include "bss.h"
#include "lib/crash.h"
#include "lib/libc/xprintf.h"
#include "data.h"
#include "types.h"
void rmonproc()
{
// empty
}
bool rmonIsDisabled(void)
{
return true;
}
s32 rmon0002fa10(void)
{
return -1;
}
void rmon0002fa18(void)
{
// empty
}
void rmon0002fa20(void)
{
// empty
}
void rmon0002fa28(void)
{
// empty
}
void rmon0002fa30(s32 *arg0, s32 arg1)
{
if (arg0);
if (arg1);
}
void rmon0002fa38(u32 arg0)
{
if (arg0);
}
void rmon0002fa40(void)
{
// empty
}
char *rmonProut(char *dst, const char *src, size_t count)
{
s32 i = 0;
while (i != count) {
crashAppendChar(src[i++]);
}
return (char *) 1;
}
void rmonPrintf(const char *format, ...)
{
va_list ap;
va_start(ap, format);
_Printf(rmonProut, NULL, format, ap);
}

5
src/lib/rzip.s
View File

@ -279,7 +279,6 @@ glabel rzipInflate
sw $sp, 0x74($sp)
sw $s8, 0x78($sp)
addiu $sp, $sp, -0x18
jal rmonPrintf
addiu $a0, $a0, %lo(errstr_unrecognised)
addiu $sp, $sp, 0x18
lw $ra, 0x0($sp)
@ -352,7 +351,6 @@ glabel rzipInflate
sw $sp, 0x74($sp)
sw $s8, 0x78($sp)
addiu $sp, $sp, -0x18
jal rmonPrintf
addiu $a0, $a0, %lo(errstr_unrecognised)
addiu $sp, $sp, 0x18
lw $ra, 0x0($sp)
@ -466,7 +464,6 @@ glabel rzipInflate
sw $v0, 0x4($sp)
lui $a0, %hi(errstr_inflatefailed)
addiu $a0, $a0, %lo(errstr_inflatefailed)
jal rmonPrintf
lw $a1, 0x4($sp)
addiu $sp, $sp, 0x18
lw $ra, 0x0($sp)
@ -898,7 +895,6 @@ glabel rzipInflateDynamic
sw $sp, 0x74($sp)
sw $s8, 0x78($sp)
addiu $sp, $sp, -24
jal rmonPrintf
addiu $a0, $a0, %lo(errstr_badlen)
addiu $sp, $sp, 0x18
lw $ra, 0x0($sp)
@ -1402,7 +1398,6 @@ glabel rzipBuildHufts
sw $s3, 0x4($sp)
lui $a0, %hi(errstr_huftsoverflow)
addiu $a0, $a0, %lo(errstr_huftsoverflow)
jal rmonPrintf
lw $a1, 0x4($sp)
addiu $sp, $sp, 0x18
lw $ra, 0x0($sp)

54
src/lib/sched.c
View File

@ -8,12 +8,10 @@
#include "lib/audiomgr.h"
#include "lib/reset.h"
#include "lib/rzip.h"
#include "lib/crash.h"
#include "lib/main.h"
#include "lib/snd.h"
#include "lib/pimgr.h"
#include "lib/profile.h"
#include "lib/rmon.h"
#include "lib/lib_48150.h"
#include "lib/vi.h"
#include "lib/joy.h"
@ -75,12 +73,6 @@ s32 g_SchedWriteArtifactsIndex;
s32 g_SchedFrontArtifactsIndex;
s32 g_SchedPendingArtifactsIndex;
bool g_SchedCrashedUnexpectedly = false;
bool g_SchedCrashEnable1 = false;
bool g_SchedCrashEnable2 = false;
u32 g_SchedCrashRenderInterval = 45000000;
u32 g_SchedCrashLastRendered = 0;
s32 var8005ce74 = 0;
f32 g_ViXScalesBySlot[2] = {1, 1};
f32 g_ViYScalesBySlot[2] = {1, 1};
@ -94,49 +86,6 @@ u32 var8005cea4 = 0;
OSScMsg g_SchedRspMsg = {OS_SC_RSP_MSG};
bool g_SchedIsFirstTask = true;
void schedSetCrashEnable1(bool enable)
{
g_SchedCrashEnable1 = enable;
}
void schedSetCrashedUnexpectedly(bool enable)
{
g_SchedCrashedUnexpectedly = enable;
}
void schedSetCrashEnable2(bool enable)
{
g_SchedCrashEnable2 = enable;
}
void schedSetCrashRenderInterval(u32 cycles)
{
g_SchedCrashRenderInterval = cycles;
}
void schedRenderCrashOnBuffer(void *framebuffer)
{
if ((g_SchedCrashEnable2 && g_SchedCrashEnable1) || g_SchedCrashedUnexpectedly) {
crashRenderFrame(framebuffer);
g_SchedCrashLastRendered = osGetCount();
}
}
void schedRenderCrashPeriodically(u32 framecount)
{
if ((framecount & 0xf) == 0 && ((g_SchedCrashEnable2 && g_SchedCrashEnable1) || g_SchedCrashedUnexpectedly)) {
if (osGetCount() - g_SchedCrashLastRendered > g_SchedCrashRenderInterval) {
crashRenderFrame(g_FrameBuffers[0]);
crashRenderFrame(g_FrameBuffers[1]);
}
}
}
void schedInitCrashLastRendered(void)
{
g_SchedCrashLastRendered = osGetCount();
}
void osCreateScheduler(OSSched *sc, OSThread *thread, u8 mode, u32 numFields)
{
sc->curRSPTask = 0;
@ -172,7 +121,6 @@ void osCreateScheduler(OSSched *sc, OSThread *thread, u8 mode, u32 numFields)
osSetEventMesg(OS_EVENT_DP, &sc->interruptQ, (OSMesg)RDP_DONE_MSG);
osViSetEvent(&sc->interruptQ, (OSMesg)VIDEO_MSG, numFields);
schedInitCrashLastRendered();
osCreateThread(sc->thread, THREAD_SCHED, &__scMain, sc, bootAllocateStack(THREAD_SCHED, STACKSIZE_SCHED), THREADPRI_SCHED);
osStartThread(sc->thread);
}
@ -294,7 +242,6 @@ void __scHandleRetrace(OSSched *sc)
joysTick();
snd0000fe18();
schedRenderCrashPeriodically(sc->frameCount);
}
extern struct sndcache g_SndCache;
@ -599,7 +546,6 @@ s32 __scTaskComplete(OSSched *sc, OSScTask *t)
g_ViUnblackTimer--;
}
schedRenderCrashOnBuffer(t->framebuffer);
osViSwapBuffer(t->framebuffer);
}

10
src/lib/str.c
View File

@ -1,19 +1,11 @@
#include <ultra64.h>
#include "lib/fault.h"
#include "types.h"
char *strcpy(char *dst, const char *src)
{
char *ptr = dst;
char c;
if (dst == NULL) {
faultAssert("s1", "str.c", 44);
}
if (src == NULL) {
faultAssert("s2", "str.c", 45);
}
*ptr = c = *src;
ptr++;
src++;

19
src/lib/videbug.c
View File

@ -1,19 +0,0 @@
#include <ultra64.h>
#include "constants.h"
#include "bss.h"
#include "data.h"
#include "types.h"
#include "lib/videbug.h"
OSMesg g_ViDebugMesgs[8];
OSMesgQueue g_ViDebugMesgQueue;
void videbugCreate(void)
{
// empty
}
void videbugInit(void)
{
osCreateMesgQueue(&g_ViDebugMesgQueue, g_ViDebugMesgs, ARRAYCOUNT(g_ViDebugMesgs));
}