From 63c456a23320c400294e7e10dc659814da13da4c Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sat, 27 Jan 2024 18:25:55 +0800 Subject: [PATCH 01/81] port-64: first changes, able to build --- Makefile.port | 15 ++++++++------- include/PR/gbi.h | 6 +++--- include/PR/os_pi.h | 2 +- port/src/libultra.c | 2 +- port/src/main.c | 1 + src/include/gunscript.h | 4 ++-- src/include/platform.h | 5 ----- src/include/types.h | 2 +- src/lib/ultra/io/pidma.c | 2 +- 9 files changed, 18 insertions(+), 21 deletions(-) diff --git a/Makefile.port b/Makefile.port index b8ebadb12..747548a78 100644 --- a/Makefile.port +++ b/Makefile.port @@ -36,7 +36,7 @@ ROMID ?= ntsc-final # # Supported values: -O0, -O1, -O2, -O3, -Os, -Og -GCC_OPT_LVL = -Og +GCC_OPT_LVL = -O0 # ROM_SIZE - The desired ROM size in megabytes. # @@ -86,12 +86,8 @@ endif # Set whether the target arch is 64- or 32-bit. ifneq (,$(findstring 64,$(TARGET_PLATFORM))$(findstring armv8,$(TARGET_PLATFORM))) - # TODO: we're not 64-bit compatible yet, error out if building the actual game - ifeq (,$(findstring clean,$(MAKECMDGOALS))) - $(error 64-bit target platforms are not supported yet) - endif TARGET_64BIT = 1 -else # TODO +else TARGET_64BIT = 0 endif @@ -137,6 +133,7 @@ DEFINES := \ PAL=$(IS_PAL) \ PIRACYCHECKS=0 \ ROM_SIZE=$(ROM_SIZE) \ + PLATFORM_64BIT=1 \ _LANGUAGE_C=1 ifeq ($(DEBUG),1) @@ -152,8 +149,12 @@ G_DIR := src/generated/$(ROMID) ifneq (,$(findstring windows,$(TARGET_PLATFORM))) TARGET_CFLAGS := $(shell pkg-config sdl2 --cflags-only-I) TARGET_LDFLAGS := $(shell pkg-config sdl2 --libs) -lz -lopengl32 -static-libstdc++ -ldbghelp + ifeq (1,$(TARGET_64BIT)) + TOOLCHAIN ?= x86_64-w64-mingw32- + else # on windows/mingw we need this to be built with a 32-bit compiler so it finds the correct libs - TOOLCHAIN ?= i686-w64-mingw32- + TOOLCHAIN ?= i686-w64-mingw32- + endif else # assume *nix TARGET_CFLAGS := $(shell pkg-config sdl2 --cflags-only-I) TARGET_LDFLAGS := $(shell pkg-config sdl2 --libs) -lGL -lz -ldl diff --git a/include/PR/gbi.h b/include/PR/gbi.h index d8fd26bf8..e36f15ec2 100644 --- a/include/PR/gbi.h +++ b/include/PR/gbi.h @@ -1538,8 +1538,8 @@ typedef struct { * Generic Gfx Packet */ typedef struct { - unsigned int w0; - unsigned int w1; + uintptr_t w0; + uintptr_t w1; } Gwords; // xxxxxxxx 11223344 44555566 66666777 @@ -1663,7 +1663,7 @@ typedef union { { \ (_SHIFTL((c), 24, 8) | _SHIFTL((p), 16, 8) | \ _SHIFTL((l), 0, 16)), \ - (unsigned int)(s) \ + (uintptr_t)(s) \ } #define gDma2p(pkt, c, adrs, len, idx, ofs) \ diff --git a/include/PR/os_pi.h b/include/PR/os_pi.h index 0c7459784..500ec916f 100644 --- a/include/PR/os_pi.h +++ b/include/PR/os_pi.h @@ -198,7 +198,7 @@ extern u32 osPiGetStatus(void); extern s32 osPiGetDeviceType(void); extern s32 osPiWriteIo(u32, u32); extern s32 osPiReadIo(u32, u32 *); -extern s32 osPiStartDma(OSIoMesg *, s32, s32, u32, void *, u32, +extern s32 osPiStartDma(OSIoMesg *, s32, s32, uintptr_t, void *, u32, OSMesgQueue *); extern void osCreatePiManager(OSPri, OSMesgQueue *, OSMesg *, s32); diff --git a/port/src/libultra.c b/port/src/libultra.c index 74edd9782..708f97bd5 100644 --- a/port/src/libultra.c +++ b/port/src/libultra.c @@ -433,7 +433,7 @@ void osInvalDCache(void *a, s32 b) } -s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, uintptr_t devAddr, void *vAddr, size_t nbytes, OSMesgQueue *mq) +s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, uintptr_t devAddr, void *vAddr, u32 nbytes, OSMesgQueue *mq) { memcpy(vAddr, (const void *)devAddr, nbytes); return 0; diff --git a/port/src/main.c b/port/src/main.c index 10150f7ae..f9af8ac1e 100644 --- a/port/src/main.c +++ b/port/src/main.c @@ -129,6 +129,7 @@ int main(int argc, const char **argv) sysLogPrintf(LOG_NOTE, "rom file at %p - %p", g_RomFile, g_RomFile + g_RomFileSize); g_SndDisabled = sysArgCheck("--no-sound"); + g_SndDisabled = true; g_StageNum = sysArgGetInt("--boot-stage", STAGE_TITLE); diff --git a/src/include/gunscript.h b/src/include/gunscript.h index 224c1dd7c..b3cd21870 100644 --- a/src/include/gunscript.h +++ b/src/include/gunscript.h @@ -17,10 +17,10 @@ { GUNCMD_PLAYSOUND, 0, keyframe, sound }, #define gunscript_include(unk1, address) \ - { GUNCMD_INCLUDE, unk1, 0, (u32)address }, + { GUNCMD_INCLUDE, unk1, 0, (uintptr_t)address }, #define gunscript_random(probability, address) \ - { GUNCMD_RANDOM, 0, probability, (u32)address }, + { GUNCMD_RANDOM, 0, probability, (uintptr_t)address }, #define gunscript_repeatuntilfull(triggerkey, dontloop, gototrigger) \ { GUNCMD_REPEATUNTILFULL, 0, triggerkey, (dontloop << 16) | gototrigger }, diff --git a/src/include/platform.h b/src/include/platform.h index 30615f750..949ff31a6 100644 --- a/src/include/platform.h +++ b/src/include/platform.h @@ -29,11 +29,6 @@ #error "Unknown CPU arch." #endif -// TODO: remove this after 64-bit support is in place -#ifdef PLATFORM_64BIT - #error "64-bit platforms are currently not supported." -#endif - // detect endianness #if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ diff --git a/src/include/types.h b/src/include/types.h index 2a0491896..41ec678d3 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -5357,7 +5357,7 @@ struct guncmd { u8 type; u8 unk01; u16 unk02; - s32 unk04; + uintptr_t unk04; }; struct pakthing { diff --git a/src/lib/ultra/io/pidma.c b/src/lib/ultra/io/pidma.c index 75d758d1b..1fc7b61d7 100644 --- a/src/lib/ultra/io/pidma.c +++ b/src/lib/ultra/io/pidma.c @@ -1,7 +1,7 @@ #include #include "piint.h" -s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, u32 devAddr, void *dramAddr, u32 size, OSMesgQueue *mq) +s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, uintptr_t devAddr, void *dramAddr, u32 size, OSMesgQueue *mq) { register s32 ret; From 3242105ef87d04d4a1f41249ac4395a48ccf9963 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sun, 26 May 2024 16:10:24 +0800 Subject: [PATCH 02/81] portx64: added pd-extract source --- port/pdextract/common.h | 71 +++ port/pdextract/ext_anims.c | 77 +++ port/pdextract/ext_audio.c | 485 ++++++++++++++++ port/pdextract/ext_banners.c | 39 ++ port/pdextract/ext_file_audio.c | 14 + port/pdextract/ext_file_bg.c | 500 +++++++++++++++++ port/pdextract/ext_file_lang.c | 110 ++++ port/pdextract/ext_file_model.c | 952 ++++++++++++++++++++++++++++++++ port/pdextract/ext_file_pads.c | 357 ++++++++++++ port/pdextract/ext_file_tiles.c | 122 ++++ port/pdextract/ext_files.c | 100 ++++ port/pdextract/ext_fonts.c | 157 ++++++ port/pdextract/ext_jpnfonts.c | 32 ++ port/pdextract/ext_textures.c | 76 +++ port/pdextract/gbi.c | 189 +++++++ port/pdextract/main.c | 173 ++++++ port/pdextract/util.c | 103 ++++ 17 files changed, 3557 insertions(+) create mode 100644 port/pdextract/common.h create mode 100644 port/pdextract/ext_anims.c create mode 100644 port/pdextract/ext_audio.c create mode 100644 port/pdextract/ext_banners.c create mode 100644 port/pdextract/ext_file_audio.c create mode 100644 port/pdextract/ext_file_bg.c create mode 100644 port/pdextract/ext_file_lang.c create mode 100644 port/pdextract/ext_file_model.c create mode 100644 port/pdextract/ext_file_pads.c create mode 100644 port/pdextract/ext_file_tiles.c create mode 100644 port/pdextract/ext_files.c create mode 100644 port/pdextract/ext_fonts.c create mode 100644 port/pdextract/ext_jpnfonts.c create mode 100644 port/pdextract/ext_textures.c create mode 100644 port/pdextract/gbi.c create mode 100644 port/pdextract/main.c create mode 100644 port/pdextract/util.c diff --git a/port/pdextract/common.h b/port/pdextract/common.h new file mode 100644 index 000000000..50f777ad0 --- /dev/null +++ b/port/pdextract/common.h @@ -0,0 +1,71 @@ +#ifndef _COMMON_H +#define _COMMON_H +#include +#include +#include + +#define srctoh16(value) be16toh(value) +#define srctoh32(value) be32toh(value) +#define srctoh64(value) be64toh(value) + +#ifdef FORCE_BE32 +#define htodst16(value) htobe16(value) +#define htodst32(value) htobe32(value) +#define htodst64(value) htobe64(value) +#define dsttoh16(value) be16toh(value) +#define dsttoh32(value) be32toh(value) +#define dsttoh64(value) be64toh(value) +#else +#define htodst16(value) (value) +#define htodst32(value) (value) +#define htodst64(value) (value) +#define dsttoh16(value) (value) +#define dsttoh32(value) (value) +#define dsttoh64(value) (value) +#endif + +#define srctodst16(value) htodst16(srctoh16(value)) +#define srctodst32(value) htodst32(srctoh32(value)) +#define srctodst64(value) htodst64(srctoh64(value)) + +#ifdef FORCE_BE32 +#define uintptr_t uint32_t +#endif + +enum romversion { + ROMVERSION_NTSC10, + ROMVERSION_NTSCFINAL, + ROMVERSION_PALFINAL, + ROMVERSION_JPNFINAL, + ROMVERSION_NTSCBETA, + ROMVERSION_PALBETA, + ROMVERSION_UNKNOWN, +}; + +extern uint8_t *g_Rom; +extern enum romversion g_RomVersion; +extern char g_OutPath[1024]; + +typedef uint32_t n64ptr_t; + +#define ALIGN(val, size) ((val + (size - 1)) & ~(size - 1)) +#define ALIGN16(val) ((val + 0xf) & ~0xf) +#define ALIGN8(val) ((val + 0x7) & ~0x7) +#define ALIGN4(val) ((val + 0x3) & ~0x3) + +#define ARRAYCOUNT(arr) (int) (sizeof(arr) / sizeof(arr[0])) + +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#define MAX(a, b) ((a) > (b) ? (a) : (b)) + +FILE *openfile(char *filename); +size_t rzip_get_infsize(uint8_t *src); +int rzip_inflate(uint8_t *dst, size_t dstlen, uint8_t *src, size_t srclen); +int rzip_deflate(uint8_t *dst, size_t *dstlen, uint8_t *src, size_t srclen); + +void gbi_reset(void); +void gbi_set_segment(int segment, uint32_t offset); +void gbi_set_vtx(uint32_t src_offset, uint32_t dst_offset); +uint32_t gbi_convert_gdl(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos); + +#endif diff --git a/port/pdextract/ext_anims.c b/port/pdextract/ext_anims.c new file mode 100644 index 000000000..09d413200 --- /dev/null +++ b/port/pdextract/ext_anims.c @@ -0,0 +1,77 @@ +#include +#include +#include +#include "common.h" + +struct animtableentry { + uint16_t numframes; + uint16_t bytesperframe; + uint32_t data; + uint16_t headerlen; + uint8_t framelen; + uint8_t flags; +}; + +static void extract_anims_data(uint32_t romoffset, size_t len) +{ + char outfilename[1024]; + sprintf(outfilename, "%s/anims_data.bin", g_OutPath); + + FILE *fp = openfile(outfilename); + fwrite(&g_Rom[romoffset], len, 1, fp); + fclose(fp); +} + +static void extract_anims_table(uint32_t romoffset) +{ + int num_anims = srctoh32(*(uint32_t *) &g_Rom[romoffset]); + struct animtableentry *srcanims = (struct animtableentry *) &g_Rom[romoffset + 4]; + + size_t dstlen = ALIGN16(4 + num_anims * sizeof(struct animtableentry)); + uint8_t *dst = calloc(1, dstlen); + *(uint32_t *) dst = htodst32(num_anims); + struct animtableentry *dstanims = (struct animtableentry *) (dst + 4); + + for (int i = 0; i < num_anims; i++) { + dstanims[i].numframes = srctodst16(srcanims[i].numframes); + dstanims[i].bytesperframe = srctodst16(srcanims[i].bytesperframe); + dstanims[i].data = srctodst32(srcanims[i].data); + dstanims[i].headerlen = srctodst16(srcanims[i].headerlen); + dstanims[i].framelen = srcanims[i].framelen; + dstanims[i].flags = srcanims[i].flags; + } + + char outfilename[1024]; + sprintf(outfilename, "%s/anims_table.bin", g_OutPath); + + FILE *fp = openfile(outfilename); + fwrite(dst, dstlen, 1, fp); + fclose(fp); + + free(dst); +} + +void extract_anims(void) +{ + uint32_t table_offset = 0; + uint32_t data_offset = 0; + + switch (g_RomVersion) { + case ROMVERSION_NTSC10: + case ROMVERSION_NTSCFINAL: + data_offset = 0x1a15c0; + table_offset = 0x7cd1a0; + break; + case ROMVERSION_PALFINAL: + data_offset = 0x18cdc0; + table_offset = 0x7b89a0; + break; + case ROMVERSION_JPNFINAL: + data_offset = 0x190c50; + table_offset = 0x7bc830; + break; + } + + extract_anims_data(data_offset, table_offset - data_offset); + extract_anims_table(table_offset); +} diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c new file mode 100644 index 000000000..8a6278e4f --- /dev/null +++ b/port/pdextract/ext_audio.c @@ -0,0 +1,485 @@ +#include +#include +#include +#include "common.h" + +enum { + AL_ADPCM_WAVE = 0, + AL_RAW16_WAVE +}; + +struct generic_adpcm_book { + int32_t order; + int32_t npredictors; + int16_t book[128]; +}; + +struct generic_adpcm_loop { + uint32_t start; + uint32_t end; + uint32_t count; + int16_t state[16]; +}; + +struct generic_raw_loop { + uint32_t start; + uint32_t end; + uint32_t count; +}; + +struct generic_envelope { + int32_t attackTime; + int32_t decayTime; + int32_t releaseTime; + uint8_t attackVolume; + uint8_t decayVolume; +}; + +struct generic_keymap { + uint8_t velocityMin; + uint8_t velocityMax; + uint8_t keyMin; + uint8_t keyMax; + uint8_t keyBase; + int8_t detune; +}; + +struct n64_adpcm_waveinfo { + uint32_t loop; // ptr to struct generic_adpcm_loop + uint32_t book; // ptr to struct generic_adpcm_book +}; + +struct host_adpcm_waveinfo { + uintptr_t loop; // ptr to struct generic_adpcm_loop + uintptr_t book; // ptr to struct generic_adpcm_book +}; + +struct n64_raw_waveinfo { + uint32_t loop; // ptr to struct generic_raw_loop +}; + +struct host_raw_waveinfo { + uintptr_t loop; // ptr to struct generic_raw_loop +}; + +struct n64_wavetable { + uint32_t base; + int32_t len; + uint8_t type; + uint8_t flags; + union { + struct n64_adpcm_waveinfo adpcmWave; + struct n64_raw_waveinfo rawWave; + } waveInfo; +}; + +struct host_wavetable { + uintptr_t base; + int32_t len; + uint8_t type; + uint8_t flags; + union { + struct host_adpcm_waveinfo adpcmWave; + struct host_raw_waveinfo rawWave; + } waveInfo; +}; + +struct n64_sound { + uint32_t envelope; // ptr to struct generic_envelope + uint32_t keyMap; // ptr to struct generic_keymap + uint32_t wavetable; // ptr to struct n64_wavetable + uint8_t samplePan; + uint8_t sampleVolume; + uint8_t flags; +}; + +struct host_sound { + uintptr_t envelope; // ptr to struct generic_envelope + uintptr_t keyMap; // ptr to struct generic_keymap + uintptr_t wavetable; // ptr to struct host_wavetable + uint8_t samplePan; + uint8_t sampleVolume; + uint8_t flags; +}; + +struct n64_instrument { + uint8_t volume; + uint8_t pan; + uint8_t priority; + uint8_t flags; + uint8_t tremType; + uint8_t tremRate; + uint8_t tremDepth; + uint8_t tremDelay; + uint8_t vibType; + uint8_t vibRate; + uint8_t vibDepth; + uint8_t vibDelay; + int16_t bendRange; + int16_t soundCount; + uint32_t soundArray[1]; // ptr to struct n64_sound +}; + +struct host_instrument { + uint8_t volume; + uint8_t pan; + uint8_t priority; + uint8_t flags; + uint8_t tremType; + uint8_t tremRate; + uint8_t tremDepth; + uint8_t tremDelay; + uint8_t vibType; + uint8_t vibRate; + uint8_t vibDepth; + uint8_t vibDelay; + int16_t bendRange; + int16_t soundCount; + uintptr_t soundArray[1]; // ptr to struct host_sound +}; + +struct n64_bank { + int16_t instCount; + uint8_t flags; + uint8_t pad; + int32_t sampleRate; + uint32_t percussion; // ptr to struct n64_instrument + uint32_t instArray[1]; // ptr to struct n64_instrument +}; + +struct host_bank { + int16_t instCount; + uint8_t flags; + uint8_t pad; + int32_t sampleRate; + uintptr_t percussion; // ptr to struct host_instrument + uintptr_t instArray[1]; // ptr to struct host_instrument +}; + +struct n64_bankfile { + int16_t revision; + int16_t bankCount; + uint32_t bankArray[1]; // ptr to struct n64_bank +}; + +struct host_bankfile { + int16_t revision; + int16_t bankCount; + uintptr_t bankArray[1]; // ptr to struct host_bank +}; + +static int convert_audio_envelope(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct generic_envelope *n64_envelope = (struct generic_envelope *) &src[srcpos]; + struct generic_envelope *host_envelope = (struct generic_envelope *) &dst[dstpos]; + + dstpos += sizeof(struct generic_envelope); + + host_envelope->attackTime = srctodst32(n64_envelope->attackTime); + host_envelope->decayTime = srctodst32(n64_envelope->decayTime); + host_envelope->releaseTime = srctodst32(n64_envelope->releaseTime); + host_envelope->attackVolume = n64_envelope->attackVolume; + host_envelope->decayVolume = n64_envelope->decayVolume; + + return dstpos; +} + +static int convert_audio_keymap(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct generic_keymap *n64_keymap = (struct generic_keymap *) &src[srcpos]; + struct generic_keymap *host_keymap = (struct generic_keymap *) &dst[dstpos]; + + dstpos += sizeof(struct generic_keymap); + + host_keymap->velocityMin = n64_keymap->velocityMin; + host_keymap->velocityMax = n64_keymap->velocityMax; + host_keymap->keyMin = n64_keymap->keyMin; + host_keymap->keyMax = n64_keymap->keyMax; + host_keymap->keyBase = n64_keymap->keyBase; + host_keymap->detune = n64_keymap->detune; + + return dstpos; +} + +static int convert_audio_adpcm_loop(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct generic_adpcm_loop *n64_loop = (struct generic_adpcm_loop *) &src[srcpos]; + struct generic_adpcm_loop *host_loop = (struct generic_adpcm_loop *) &dst[dstpos]; + + dstpos += sizeof(struct generic_adpcm_loop); + + host_loop->start = srctodst32(n64_loop->start); + host_loop->end = srctodst32(n64_loop->end); + host_loop->count = srctodst32(n64_loop->count); + + for (int i = 0; i < ARRAYCOUNT(host_loop->state); i++) { + host_loop->state[i] = srctodst16(n64_loop->state[i]); + } + + return dstpos; +} + +static int convert_audio_adpcm_book(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct generic_adpcm_book *n64_book = (struct generic_adpcm_book *) &src[srcpos]; + struct generic_adpcm_book *host_book = (struct generic_adpcm_book *) &dst[dstpos]; + + dstpos += sizeof(struct generic_adpcm_book); + + host_book->order = srctodst32(n64_book->order); + host_book->npredictors = srctodst32(n64_book->npredictors); + + for (int i = 0; i < ARRAYCOUNT(host_book->book); i++) { + host_book->book[i] = srctodst16(n64_book->book[i]); + } + + return dstpos; +} + +static int convert_audio_raw_loop(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct generic_raw_loop *n64_loop = (struct generic_raw_loop *) &src[srcpos]; + struct generic_raw_loop *host_loop = (struct generic_raw_loop *) &dst[dstpos]; + + dstpos += sizeof(struct generic_raw_loop); + + host_loop->start = srctodst32(n64_loop->start); + host_loop->end = srctodst32(n64_loop->end); + host_loop->count = srctodst32(n64_loop->count); + + return dstpos; +} + +static int convert_audio_wavetable(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct n64_wavetable *n64_wavetable = (struct n64_wavetable *) &src[srcpos]; + struct host_wavetable *host_wavetable = (struct host_wavetable *) &dst[dstpos]; + + dstpos += sizeof(struct host_wavetable); + + host_wavetable->base = srctodst32(n64_wavetable->base); + host_wavetable->len = srctodst32(n64_wavetable->len); + host_wavetable->type = n64_wavetable->type; + host_wavetable->flags = n64_wavetable->flags; + + if (host_wavetable->type == AL_ADPCM_WAVE) { + if (n64_wavetable->waveInfo.adpcmWave.loop) { + host_wavetable->waveInfo.adpcmWave.loop = htodst32(dstpos); + srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.loop); + dstpos = convert_audio_adpcm_loop(dst, dstpos, src, srcpos); + } else { + host_wavetable->waveInfo.adpcmWave.loop = 0; + } + + if (n64_wavetable->waveInfo.adpcmWave.book) { + host_wavetable->waveInfo.adpcmWave.book = htodst32(dstpos); + srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.book); + dstpos = convert_audio_adpcm_book(dst, dstpos, src, srcpos); + } else { + host_wavetable->waveInfo.adpcmWave.book = 0; + } + } else if (host_wavetable->type == AL_RAW16_WAVE) { + if (n64_wavetable->waveInfo.rawWave.loop) { + host_wavetable->waveInfo.rawWave.loop = htodst32(dstpos); + srcpos = srctoh32(n64_wavetable->waveInfo.rawWave.loop); + dstpos = convert_audio_raw_loop(dst, dstpos, src, srcpos); + } else { + host_wavetable->waveInfo.rawWave.loop = 0; + } + } + + return dstpos; +} + +static int convert_audio_sound(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct n64_sound *n64_sound = (struct n64_sound *) &src[srcpos]; + struct host_sound *host_sound = (struct host_sound *) &dst[dstpos]; + + dstpos += sizeof(struct host_sound); + + if (n64_sound->envelope) { + host_sound->envelope = htodst32(dstpos); + srcpos = srctoh32(n64_sound->envelope); + dstpos = convert_audio_envelope(dst, dstpos, src, srcpos); + } else { + host_sound->envelope = 0; + } + + if (n64_sound->keyMap) { + host_sound->keyMap = htodst32(dstpos); + srcpos = srctoh32(n64_sound->keyMap); + dstpos = convert_audio_keymap(dst, dstpos, src, srcpos); + } else { + host_sound->keyMap = 0; + } + + if (n64_sound->wavetable) { + host_sound->wavetable = htodst32(dstpos); + srcpos = srctoh32(n64_sound->wavetable); + dstpos = convert_audio_wavetable(dst, dstpos, src, srcpos); + } else { + host_sound->wavetable = 0; + } + + host_sound->samplePan = n64_sound->samplePan; + host_sound->sampleVolume = n64_sound->sampleVolume; + host_sound->flags = n64_sound->flags; + + return dstpos; +} + +static int convert_audio_instrument(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct n64_instrument *n64_instrument = (struct n64_instrument *) &src[srcpos]; + struct host_instrument *host_instrument = (struct host_instrument *) &dst[dstpos]; + int soundCount = srctoh16(n64_instrument->soundCount); + + host_instrument->volume = n64_instrument->volume; + host_instrument->pan = n64_instrument->pan; + host_instrument->priority = n64_instrument->priority; + host_instrument->flags = n64_instrument->flags; + host_instrument->tremType = n64_instrument->tremType; + host_instrument->tremRate = n64_instrument->tremRate; + host_instrument->tremDepth = n64_instrument->tremDepth; + host_instrument->tremDelay = n64_instrument->tremDelay; + host_instrument->vibType = n64_instrument->vibType; + host_instrument->vibRate = n64_instrument->vibRate; + host_instrument->vibDepth = n64_instrument->vibDepth; + host_instrument->vibDelay = n64_instrument->vibDelay; + host_instrument->bendRange = srctodst16(n64_instrument->bendRange); + host_instrument->soundCount = htodst16(soundCount); + + dstpos = dstpos + sizeof(struct host_instrument) + sizeof(uintptr_t) * (soundCount - 1); + + for (int i = 0; i < soundCount; i++) { + host_instrument->soundArray[i] = htodst32(dstpos); + srcpos = srctoh32(n64_instrument->soundArray[i]); + dstpos = convert_audio_sound(dst, dstpos, src, srcpos); + } + + return dstpos; +} + +static int convert_audio_bank(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct n64_bank *n64_bank = (struct n64_bank *) &src[srcpos]; + struct host_bank *host_bank = (struct host_bank *) &dst[dstpos]; + int instCount = srctoh16(n64_bank->instCount); + + host_bank->instCount = htodst16(instCount); + host_bank->flags = n64_bank->flags; + host_bank->pad = n64_bank->pad; + host_bank->sampleRate = srctodst32(n64_bank->sampleRate); + + dstpos = dstpos + sizeof(struct host_bank) + sizeof(uintptr_t) * (instCount - 1); + + if (n64_bank->percussion) { + host_bank->percussion = htodst32(dstpos); + srcpos = srctoh32(n64_bank->percussion); + dstpos = convert_audio_instrument(dst, dstpos, src, srcpos); + } else { + host_bank->percussion = 0; + } + + for (int i = 0; i < instCount; i++) { + host_bank->instArray[i] = htodst32(dstpos); + srcpos = srctoh32(n64_bank->instArray[i]); + dstpos = convert_audio_instrument(dst, dstpos, src, srcpos); + } + + return dstpos; +} + +static int convert_audio_bankfile(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct n64_bankfile *n64_bankfile = (struct n64_bankfile *) &src[srcpos]; + struct host_bankfile *host_bankfile = (struct host_bankfile *) &dst[dstpos]; + int bankCount = srctoh16(n64_bankfile->bankCount); + + host_bankfile->revision = srctodst16(n64_bankfile->revision); + host_bankfile->bankCount = htodst16(bankCount); + + dstpos = dstpos + sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); + + for (int i = 0; i < bankCount; i++) { + host_bankfile->bankArray[i] = htodst32(dstpos); + srcpos = srctoh32(n64_bankfile->bankArray[i]); + dstpos = convert_audio_bank(dst, dstpos, src, srcpos); + } + + return dstpos; +} + +static void extract_audio_ctl(const char *filename, uint32_t romoffset, size_t srclen) +{ + size_t dstlen = srclen * 4; + uint8_t *src = &g_Rom[romoffset]; + uint8_t *dst = calloc(1, dstlen); + int dstpos = 0; + + dstpos = convert_audio_bankfile(dst, dstpos, src, 0); + + char outfilename[1024]; + sprintf(outfilename, "%s/%s.ctl", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(dst, ALIGN16(dstpos), 1, fp); + fclose(fp); + + free(dst); +} + +static void extract_audio_tbl(const char *filename, uint32_t romoffset, size_t len) +{ + char outfilename[1024]; + sprintf(outfilename, "%s/%s.tbl", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(&g_Rom[romoffset], len, 1, fp); + fclose(fp); +} + +void extract_audio(void) +{ + uint32_t sfx_ctl = 0; + uint32_t sfx_tbl = 0; + uint32_t sfx_end = 0; + + uint32_t seq_ctl = 0; + uint32_t seq_tbl = 0; + uint32_t seq_end = 0; + + switch (g_RomVersion) { + case ROMVERSION_NTSC10: + case ROMVERSION_NTSCFINAL: + sfx_ctl = 0x80a250; + sfx_tbl = 0x839dd0; + sfx_end = 0xcfbf30; + seq_ctl = 0xcfbf30; + seq_tbl = 0xd05f90; + seq_end = 0xe82000; + break; + case ROMVERSION_PALFINAL: + sfx_ctl = 0x7f87e0; + sfx_tbl = 0x828360; + sfx_end = 0xcea4c0; + seq_ctl = 0xcea4c0; + seq_tbl = 0xcf4520; + seq_end = 0xe70590; + break; + case ROMVERSION_JPNFINAL: + sfx_ctl = 0x7fc670; + sfx_tbl = 0x82c1f0; + sfx_end = 0xcee350; + seq_ctl = 0xcee350; + seq_tbl = 0xcf83b0; + seq_end = 0xe74420; + break; + } + + extract_audio_ctl("sfx", sfx_ctl, sfx_tbl - sfx_ctl); + extract_audio_tbl("sfx", sfx_tbl, sfx_end - sfx_tbl); + extract_audio_ctl("seq", seq_ctl, seq_tbl - seq_ctl); + extract_audio_tbl("seq", seq_tbl, seq_end - seq_tbl); +} diff --git a/port/pdextract/ext_banners.c b/port/pdextract/ext_banners.c new file mode 100644 index 000000000..dd9b3370e --- /dev/null +++ b/port/pdextract/ext_banners.c @@ -0,0 +1,39 @@ +#include +#include +#include +#include "common.h" + +void extract_banner(const char *filename, uint32_t romoffset, size_t len) +{ + char outfilename[1024]; + sprintf(outfilename, "%s/%s.bin", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(&g_Rom[romoffset], len, 1, fp); + fclose(fp); +} + +void extract_banners(void) +{ + uint32_t accessingpak = 0; + uint32_t copyright = 0; + + switch (g_RomVersion) { + case ROMVERSION_NTSC10: + case ROMVERSION_NTSCFINAL: + copyright = 0x1ffea20; + accessingpak = 0x1fff550; + break; + case ROMVERSION_PALFINAL: + copyright = 0x1ff5500; + accessingpak = 0x1ff6030; + break; + case ROMVERSION_JPNFINAL: + copyright = 0x1ffd6b0; + accessingpak = 0x1ffe1e0; + break; + } + + extract_banner("copyright", copyright, 0xb30); + extract_banner("accessingpak", accessingpak, 0x8b0); +} diff --git a/port/pdextract/ext_file_audio.c b/port/pdextract/ext_file_audio.c new file mode 100644 index 000000000..3411034fa --- /dev/null +++ b/port/pdextract/ext_file_audio.c @@ -0,0 +1,14 @@ +#include +#include +#include +#include "common.h" + +void extract_file_audio(char *filename, uint32_t romoffset, size_t len) +{ + char outfilename[1024]; + sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(&g_Rom[romoffset], len, 1, fp); + fclose(fp); +} diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c new file mode 100644 index 000000000..ec8a15a07 --- /dev/null +++ b/port/pdextract/ext_file_bg.c @@ -0,0 +1,500 @@ +#include +#include +#include +#include +#include "common.h" + +/** + * 4 bytes decompressed size of primary data + * 4 bytes compressed size of section 1 in its entirety + * 4 bytes compressed size of primary data + * Section 1: + * Primary: (zipped) + * 4 bytes null + * 4 bytes pointer to room table + * 4 bytes pointer to portal table + * 4 bytes pointer to bgcmds + * 4 bytes pointer to lights table + * 4 bytes null + * (room table) + * (portal table) + * (bgcmds) + * (lights table) + * room 1 (zipped) + * room 2 (zipped) + * ... + * Section 2: + * 2 bytes decompressed size of section (mask with 0x7fff) + * 2 bytes compressed size of section + * Texture ID list (zipped) + * Section 3: + * 2 bytes decompressed size of section (mask with 0x7fff) + * 2 bytes compressed size of section + * Zipped: + * (room bbox table) + * (list of roomgfxdata sizes) + * (list of light counts per room) + */ + +struct fileheader { + uint32_t primary_infsize; + uint32_t section1_cmpsize; + uint32_t primary_cmpsize; +}; + +struct sectionheader { + uint16_t infsize; + uint16_t cmpsize; +}; + +struct n64_primaryheader { + uint32_t unused1; + uint32_t ptr_rooms; + uint32_t ptr_portals; + uint32_t ptr_bgcmds; + uint32_t ptr_lights; + uint32_t unused2; +}; + +struct host_primaryheader { + uintptr_t unused1; + uintptr_t ptr_rooms; + uintptr_t ptr_portals; + uintptr_t ptr_bgcmds; + uintptr_t ptr_lights; + uintptr_t unused2; +}; + +struct n64_room { + uint32_t ptr_gfxdata; + uint32_t pos[3]; + uint8_t br_light_min; + uint8_t br_light_max; +}; + +struct host_room { + uintptr_t ptr_gfxdata; + uint32_t pos[3]; + uint8_t br_light_min; + uint8_t br_light_max; +}; + +struct portal { + uint16_t verticesoffset; + int16_t roomnum1; + int16_t roomnum2; + uint8_t flags; +}; + +struct portalvertices { + uint8_t count; + uint32_t vertices[1][3]; +}; + +struct bgcmd { + uint8_t type; + uint8_t len; + int32_t param; +}; + +struct light { + uint16_t roomnum; + uint16_t colour; + uint8_t brightness; + uint8_t sparkable : 1; + uint8_t healthy : 1; + uint8_t on : 1; + uint8_t sparking : 1; + uint8_t vulnerable : 1; + uint8_t brightnessmult; + int8_t dirx; + int8_t diry; + int8_t dirz; + int16_t bbox[4][3]; +}; + +int m_NumRooms; + +uint16_t m_AllocSizes[512]; + +static void convert_primary_rooms(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +{ + struct n64_room *n64_rooms = (struct n64_room *) &src[*srcpos]; + struct host_room *host_rooms = (struct host_room *) &dst[*dstpos]; + + m_NumRooms = 0; + + for (int i = 1; n64_rooms[i].ptr_gfxdata != 0; i++) { + m_NumRooms++; + } + + for (int i = 0; i < m_NumRooms + 1; i++) { + host_rooms[i].ptr_gfxdata = 0; // Not known at this point + host_rooms[i].pos[0] = srctodst32(n64_rooms[i].pos[0]); + host_rooms[i].pos[1] = srctodst32(n64_rooms[i].pos[1]); + host_rooms[i].pos[2] = srctodst32(n64_rooms[i].pos[2]); + host_rooms[i].br_light_min = n64_rooms[i].br_light_min; + host_rooms[i].br_light_max = n64_rooms[i].br_light_max; + } + + *srcpos += sizeof(*n64_rooms) * (m_NumRooms + 1); + *dstpos += sizeof(*host_rooms) * (m_NumRooms + 1); +} + +static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +{ + struct portal *n64_portals = (struct portal *) &src[*srcpos]; + struct portal *host_portals = (struct portal *) &dst[*dstpos]; + + // Count portals + int numportals = 0; + + for (int i = 0; n64_portals[i].verticesoffset != 0; i++) { + numportals++; + } + + // Convert portals + for (int i = 0; i < numportals; i++) { + host_portals[i].verticesoffset = srctodst16(n64_portals[i].verticesoffset); + host_portals[i].roomnum1 = srctodst16(n64_portals[i].roomnum1); + host_portals[i].roomnum2 = srctodst16(n64_portals[i].roomnum2); + host_portals[i].flags = n64_portals[i].flags; + } + + *srcpos += sizeof(*n64_portals) * (numportals + 1); + *dstpos += sizeof(*host_portals) * (numportals + 1); + + // Convert portal vertices + uint8_t *n64_vtxdata = &src[*srcpos]; + uint8_t *host_vtxdata = &dst[*dstpos]; + + for (int i = 0; i < numportals; i++) { + struct portalvertices *n64_pvertices = (struct portalvertices*) &n64_vtxdata[*srcpos]; + struct portalvertices *host_pvertices = (struct portalvertices*) &host_vtxdata[*dstpos]; + + host_pvertices->count = n64_pvertices->count; + + for (int j = 0; j < host_pvertices->count; j++) { + host_pvertices->vertices[j][0] = srctodst32(n64_pvertices->vertices[j][0]); + host_pvertices->vertices[j][1] = srctodst32(n64_pvertices->vertices[j][1]); + host_pvertices->vertices[j][2] = srctodst32(n64_pvertices->vertices[j][2]); + } + + *srcpos += 4 + host_pvertices->count * 12; + *dstpos += 4 + host_pvertices->count * 12; + } +} + +static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +{ + struct bgcmd *n64_cmds = (struct bgcmd *) &src[*srcpos]; + struct bgcmd *host_cmds = (struct bgcmd *) &dst[*dstpos]; + int num_cmds = 0; + + for (int i = 0; n64_cmds[i].type != 0; i++) { + num_cmds++; + } + + num_cmds++; + + for (int i = 0; i < num_cmds; i++) { + host_cmds[i].type = n64_cmds[i].type; + host_cmds[i].len = n64_cmds[i].len; + host_cmds[i].param = srctodst32(n64_cmds[i].param); + } + + *srcpos += sizeof(*n64_cmds) * num_cmds; + *dstpos += sizeof(*host_cmds) * num_cmds; +} + +static void convert_primary_lights(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t end) +{ + struct light *n64_lights = (struct light *) &src[*srcpos]; + struct light *host_lights = (struct light *) &dst[*dstpos]; + int num_lights = (end - *srcpos) / sizeof(struct light); + + for (int i = 0; i < num_lights; i++) { + host_lights[i].roomnum = srctodst16(n64_lights[i].roomnum); + host_lights[i].colour = srctodst16(n64_lights[i].colour); + host_lights[i].brightness = n64_lights[i].brightness; + host_lights[i].sparkable = n64_lights[i].sparkable; + host_lights[i].healthy = n64_lights[i].healthy; + host_lights[i].on = n64_lights[i].on; + host_lights[i].sparking = n64_lights[i].sparking; + host_lights[i].vulnerable = n64_lights[i].vulnerable; + host_lights[i].brightnessmult = n64_lights[i].brightnessmult; + host_lights[i].dirx = n64_lights[i].dirx; + host_lights[i].diry = n64_lights[i].diry; + host_lights[i].dirz = n64_lights[i].dirz; + + for (int j = 0; j < 4; j++) { + host_lights[i].bbox[j][0] = srctodst16(n64_lights[i].bbox[j][0]); + host_lights[i].bbox[j][1] = srctodst16(n64_lights[i].bbox[j][1]); + host_lights[i].bbox[j][2] = srctodst16(n64_lights[i].bbox[j][2]); + } + } + + *srcpos += sizeof(*n64_lights) * num_lights; + *dstpos += sizeof(*host_lights) * num_lights; +} + +static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos) +{ + return dstpos; +} + +static size_t sum(uint8_t *ptr, uint8_t *end) +{ + size_t sum = 0; + + while (ptr < end) { + sum = (sum + *ptr) & 0xffffffff; + ptr++; + } + + return sum; +} + +static uint32_t convert_section1(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, struct fileheader *n64_header) +{ + struct fileheader *host_header = (struct fileheader *) &dst[dstpos]; + dstpos += sizeof(*host_header); + + // Unzip primary + size_t infsize = srctoh32(n64_header->primary_infsize); + uint8_t *srcbin = calloc(1, infsize); + uint8_t *dstbin = calloc(1, infsize * 2); + uint32_t srcbinpos = 0; + uint32_t dstbinpos = 0; + + int ret = rzip_inflate(srcbin, infsize, &src[srcpos], srctoh32(n64_header->primary_cmpsize)); + + if (ret < 0) { + fprintf(stderr, "Unable to inflate BG primary data: %d\n", ret); + exit(EXIT_FAILURE); + } + + // Convert primary + struct host_primaryheader *host_primary_header = (struct host_primaryheader *) &dstbin[dstbinpos]; + srcbinpos += sizeof(struct n64_primaryheader); + dstbinpos += sizeof(*host_primary_header); + + host_primary_header->unused1 = 0; + host_primary_header->unused2 = 0; + + host_primary_header->ptr_rooms = dstbinpos; + convert_primary_rooms(dstbin, &dstbinpos, srcbin, &srcbinpos); + + host_primary_header->ptr_portals = dstbinpos; + convert_primary_portals(dstbin, &dstbinpos, srcbin, &srcbinpos); + + host_primary_header->ptr_bgcmds = dstbinpos; + convert_primary_bgcmds(dstbin, &dstbinpos, srcbin, &srcbinpos); + + host_primary_header->ptr_lights = dstbinpos; + convert_primary_lights(dstbin, &dstbinpos, srcbin, &srcbinpos, infsize); + + // Convert room gfxdata + uint32_t n64_primary_diff = n64_header->primary_infsize - n64_header->primary_cmpsize; + struct n64_room *n64_rooms = (struct n64_room *) &src[sizeof(*n64_header)]; + struct host_room *host_rooms = (struct host_room *) &dst[dstbinpos]; + + uint8_t *roomgfxbuf = calloc(1, 1024 * 1024); + uint8_t *allcmp = calloc(1, 1024 * 1024); + int roomgfxbufpos = 0; + int cmppos = 0; + + //for (int i = 0; i < m_NumRooms; i++) { + // host_rooms[i].ptr_gfxdata = dstbinpos + cmppos; + + // srcpos = srctoh32(n64_rooms[i].ptr_gfxdata) - n64_primary_diff; + // roomgfxbufpos = convert_section1_roomgfxdata(roomgfxbuf, 0, src, srcpos); + + // size_t ziplen = 0; + // ret = rzip_deflate(&allcmp[cmppos], &ziplen, roomgfxbuf, roomgfxbufpos); + + // if (ret < 0) { + // fprintf(stderr, "Unable to compress BG roomgfxdata for room 0x%x: %d\n", i, ret); + // exit(EXIT_FAILURE); + // } + + // ziplen = ALIGN16(ziplen); + // cmppos += ziplen; + //} + + // Zip primary + size_t ziplen = 0; + + printf("dstbin:%d = %p\n", __LINE__, dstbin); + printf("dstpos:%d = %d\n", __LINE__, dstpos); + printf("dstbinpos:%d = %d\n", __LINE__, dstbinpos); + ret = rzip_deflate(&dst[dstpos], &ziplen, dstbin, dstbinpos); + + if (ret < 0) { + fprintf(stderr, "Unable to compress BG primary data: %d\n", ret); + exit(EXIT_FAILURE); + } + + printf("ziplen:%d = %d\n", __LINE__, ziplen); + ziplen = ALIGN16(ziplen); + dstpos += ziplen; + + // Paste compressed roomgfxdata after it + memcpy(&dst[dstpos], allcmp, cmppos); + dstpos += cmppos; + + free(roomgfxbuf); + free(allcmp); + free(srcbin); + free(dstbin); + + host_header->primary_infsize = dstbinpos; + host_header->section1_cmpsize = ziplen + cmppos; + host_header->primary_cmpsize = ziplen; + + return dstpos; +} + +static void convert_section2_texturenums(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t srclen) +{ + uint16_t *src_ids = (uint16_t *) &src[*srcpos]; + uint16_t *dst_ids = (uint16_t *) &dst[*dstpos]; + int count = srclen / sizeof(uint16_t); + + for (int i = 0; i < count; i++) { + dst_ids[i] = srctodst16(src_ids[i]); + } + + *srcpos += srclen; + *dstpos += srclen; +} + +static void convert_section3_bboxes(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +{ + int16_t *src_bboxes = (int16_t *) &src[*srcpos]; + int16_t *dst_bboxes = (int16_t *) &dst[*dstpos]; + + for (int i = 0; i < m_NumRooms; i++) { + dst_bboxes[i * 6 + 0] = srctodst16(src_bboxes[i * 6 + 0]); + dst_bboxes[i * 6 + 1] = srctodst16(src_bboxes[i * 6 + 1]); + dst_bboxes[i * 6 + 2] = srctodst16(src_bboxes[i * 6 + 2]); + dst_bboxes[i * 6 + 3] = srctodst16(src_bboxes[i * 6 + 3]); + dst_bboxes[i * 6 + 4] = srctodst16(src_bboxes[i * 6 + 4]); + dst_bboxes[i * 6 + 5] = srctodst16(src_bboxes[i * 6 + 5]); + } + + *srcpos += sizeof(int16_t) * 6 * (m_NumRooms - 1); + *dstpos += sizeof(int16_t) * 6 * (m_NumRooms - 1); +} + +static void convert_section3_allocsizes(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +{ + uint16_t *dst_sizes = (uint16_t *) &dst[*dstpos]; + + for (int i = 0; i < m_NumRooms; i++) { + dst_sizes[i] = m_AllocSizes[i]; + } + + *srcpos += sizeof(uint16_t) * (m_NumRooms - 1); + *dstpos += sizeof(uint16_t) * (m_NumRooms - 1); +} + +static void convert_section3_lightcounts(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +{ + memcpy(&dst[*dstpos], &src[*srcpos], m_NumRooms); + + *srcpos += (m_NumRooms - 1); + *dstpos += (m_NumRooms - 1); +} + +static uint32_t convert_zipped_section(int section_num, uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, struct sectionheader *n64_header) +{ + struct sectionheader *host_header = (struct sectionheader *) &dst[dstpos]; + dstpos += sizeof(*host_header); + + // Unzip + size_t infsize = rzip_get_infsize(&src[srcpos]); + uint8_t *srcbin = calloc(1, infsize); + uint8_t *dstbin = calloc(1, infsize); + uint32_t srcbinpos = 0; + uint32_t dstbinpos = 0; + + int ret = rzip_inflate(srcbin, infsize, &src[srcpos], srctoh16(n64_header->cmpsize)); + + if (ret < 0) { + fprintf(stderr, "Unable to inflate BG section %d: %d\n", section_num, ret); + exit(EXIT_FAILURE); + } + + // Convert + if (section_num == 2) { + convert_section2_texturenums(dstbin, &dstbinpos, srcbin, &srcbinpos, infsize); + } else if (section_num == 3) { + convert_section3_bboxes(dstbin, &dstbinpos, srcbin, &srcbinpos); + convert_section3_allocsizes(dstbin, &dstbinpos, srcbin, &srcbinpos); + convert_section3_lightcounts(dstbin, &dstbinpos, srcbin, &srcbinpos); + } + + // Zip + size_t ziplen = 0; + + ret = rzip_deflate(&dst[dstpos], &ziplen, dstbin, dstbinpos); + + if (ret < 0) { + fprintf(stderr, "Unable to compress BG section %d: %d\n", section_num, ret); + exit(EXIT_FAILURE); + } + + ziplen = ALIGN16(ziplen); + + host_header->infsize = dstbinpos; + host_header->cmpsize = ziplen; + + dstpos += ziplen; + + free(srcbin); + free(dstbin); + + return dstpos; +} + +void extract_file_bg(char *filename, uint32_t romoffset, size_t len) +{ + if (0) { + if (strcmp(filename, "bgdata/bg_mp5.seg") != 0) { + return; + } + } + return; + + size_t dstlen = len * 2; + uint8_t *dst = calloc(1, dstlen); + uint32_t dstpos = 0; + + printf("--------------------------------------------------------------------------------\n"); + printf("-- %s\n", filename); + + uint8_t *src = &g_Rom[romoffset]; + struct fileheader *n64_fileheader = (struct fileheader *) src; + uint32_t n64_section2_start = sizeof(*n64_fileheader) + srctoh32(n64_fileheader->section1_cmpsize); + struct sectionheader *n64_section2header = (struct sectionheader *) &src[n64_section2_start]; + uint32_t n64_section3_start = n64_section2_start + sizeof(*n64_section2header) + (srctoh16(n64_section2header->cmpsize) & 0x7fff); + struct sectionheader *n64_section3header = (struct sectionheader *) &src[n64_section3_start]; + + printf("section2_start 0x%x\n", n64_section2_start); + printf("section3_start 0x%x\n", n64_section3_start); + + dstpos = convert_section1(dst, dstpos, src, sizeof(*n64_fileheader), n64_fileheader); + dstpos = convert_zipped_section(2, dst, dstpos, src, n64_section2_start + sizeof(*n64_section2header), n64_section2header); + dstpos = convert_zipped_section(3, dst, dstpos, src, n64_section3_start + sizeof(*n64_section3header), n64_section3header); + dstpos = ALIGN16(dstpos); + + char outfilename[1024]; + sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(dst, dstpos, 1, fp); + fclose(fp); + + free(dst); +} diff --git a/port/pdextract/ext_file_lang.c b/port/pdextract/ext_file_lang.c new file mode 100644 index 000000000..471cba49e --- /dev/null +++ b/port/pdextract/ext_file_lang.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include "common.h" + +static int get_next_nonzero(uint8_t *src, uint32_t offset, size_t len) +{ + uint32_t *ptr = (uint32_t *) &src[offset]; + uint32_t *end = (uint32_t *) &src[len]; + + while (ptr < end) { + if (*ptr != 0) { + return srctoh32(*ptr); + } + + ptr++; + } + + return 0; +} + +static int get_num_strings(uint8_t *src, size_t len) +{ + uint32_t ptr_table_len = get_next_nonzero(src, 0, len); + + if (ptr_table_len) { + return ptr_table_len / sizeof(uint32_t); + } + + return 1; +} + +void extract_file_lang(char *filename, uint32_t romoffset, size_t srclen) +{ + // Unzip it + size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); + uint8_t *src = malloc(infsize); + + int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], srclen); + + if (ret < 0) { + fprintf(stderr, "%s: Unable to inflate file: %d\n", filename, ret); + exit(EXIT_FAILURE); + } + + // Convert it + uint32_t *src_offsets = (uint32_t *) src; + size_t src_ptr_table_len = srctoh32(src_offsets[0]); + size_t src_str_table_len = infsize - src_ptr_table_len; + int num_strings = get_num_strings(src, srclen); + size_t dst_ptr_table_len = num_strings * sizeof(uintptr_t); + size_t dst_str_table_len = src_str_table_len; + + uint8_t *dst = calloc(1, dst_ptr_table_len + dst_str_table_len + 0x20); + int cur_dst_offset = dst_ptr_table_len; + + uintptr_t *dst_offsets = (uintptr_t *) dst; + + for (int i = 0; i < num_strings; i++) { + uint32_t src_offset = srctoh32(src_offsets[i]); + + if (src_offset) { + // Write pointer + dst_offsets[i] = htodst32(cur_dst_offset); + + // Write string + uint32_t end = get_next_nonzero(src, (i + 1) * 4, num_strings * 4); + + if (!end) { + end = infsize; + } + + size_t len = end - src_offset; + len = ALIGN4(len); + memcpy(&dst[cur_dst_offset], &src[src_offset], len); + + cur_dst_offset += len; + } else { + // Write pointer + dst_offsets[i] = 0; + } + } + + cur_dst_offset = ALIGN16(cur_dst_offset); + + // Zip it + uint8_t *zipped = calloc(1, cur_dst_offset); + size_t ziplen = cur_dst_offset; + + ret = rzip_deflate(zipped, &ziplen, dst, cur_dst_offset); + + if (ret < 0) { + fprintf(stderr, "%s: Unable to compress file: %d\n", filename, ret); + exit(EXIT_FAILURE); + } + + ziplen = ALIGN16(ziplen); + + // Write it + char outfilename[1024]; + sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(zipped, ziplen, 1, fp); + fclose(fp); + + free(zipped); + free(dst); + free(src); +} diff --git a/port/pdextract/ext_file_model.c b/port/pdextract/ext_file_model.c new file mode 100644 index 000000000..aef347484 --- /dev/null +++ b/port/pdextract/ext_file_model.c @@ -0,0 +1,952 @@ +#include +#include +#include +#include "common.h" + +enum contenttype { + /* 0*/ CT_MODELDEF, + /* 1*/ CT_NODE, + /* 2*/ CT_TEXCONFIG, + /* 3*/ CT_TEXDATA, + /* 4*/ CT_PARTS, + /* 5*/ CT_VTXCOL, + /* 6*/ CT_GDL, + /* 7*/ CT_RODATA_CHRINFO, + /* 8*/ CT_RODATA_POSITION, + /* 9*/ CT_RODATA_GUNDL, + /*10*/ CT_RODATA_DISTANCE, + /*11*/ CT_RODATA_REORDER, + /*12*/ CT_RODATA_BBOX, + /*13*/ CT_RODATA_CHRGUNFIRE, + /*14*/ CT_RODATA_11, + /*15*/ CT_RODATA_TOGGLE, + /*16*/ CT_RODATA_POSITIONHELD, + /*17*/ CT_RODATA_STARGUNFIRE, + /*18*/ CT_RODATA_HEADSPOT, + /*19*/ CT_RODATA_DL, + /*20*/ CT_RODATA_19, +}; + +struct marker { + uint32_t src_offset; + uint32_t dst_offset; + uint32_t parent_src_offset; + enum contenttype type; +}; + +struct alignconfig { + int before; + int after; +}; + +struct alignconfig m_AlignConfigs[] = { + /* 0*/ { 16, 4 }, + /* 1*/ { 4, 4 }, + /* 2*/ { 4, 4 }, + /* 3*/ { 8, 8 }, + /* 4*/ { 4, 4 }, + /* 5*/ { 4, 8 }, + /* 6*/ { 8, 8 }, + /* 7*/ { 4, 4 }, + /* 8*/ { 4, 4 }, + /* 9*/ { 8, 4 }, + /*10*/ { 4, 8 }, + /*11*/ { 4, 4 }, + /*12*/ { 4, 4 }, + /*13*/ { 4, 4 }, + /*14*/ { 4, 4 }, + /*15*/ { 4, 4 }, + /*16*/ { 4, 4 }, + /*17*/ { 8, 8 }, + /*18*/ { 4, 4 }, + /*19*/ { 8, 8 }, + /*20*/ { 4, 4 }, +}; + +struct marker m_Markers[1024]; +int m_NumMarkers; + +#define MODELNODETYPE_CHRINFO 0x01 +#define MODELNODETYPE_POSITION 0x02 +#define MODELNODETYPE_GUNDL 0x04 +#define MODELNODETYPE_05 0x05 +#define MODELNODETYPE_DISTANCE 0x08 +#define MODELNODETYPE_REORDER 0x09 +#define MODELNODETYPE_BBOX 0x0a +#define MODELNODETYPE_0B 0x0b +#define MODELNODETYPE_CHRGUNFIRE 0x0c +#define MODELNODETYPE_0D 0x0d +#define MODELNODETYPE_0E 0x0e +#define MODELNODETYPE_0F 0x0f +#define MODELNODETYPE_11 0x11 +#define MODELNODETYPE_TOGGLE 0x12 +#define MODELNODETYPE_POSITIONHELD 0x15 +#define MODELNODETYPE_STARGUNFIRE 0x16 +#define MODELNODETYPE_HEADSPOT 0x17 +#define MODELNODETYPE_DL 0x18 +#define MODELNODETYPE_19 0x19 +#define MODELNODETYPE_0100 0x0100 +#define MODELNODETYPE_0200 0x0200 + +struct src_modeldef { + uint32_t ptr_rootnode; + uint32_t ptr_skel; + uint32_t ptr_parts; + int16_t numparts; + int16_t nummatrices; + uint32_t scale; + uint16_t rwdatalen; + uint16_t numtexconfigs; + uint32_t ptr_texconfigs; +}; + +struct dst_modeldef { + uintptr_t ptr_rootnode; + uintptr_t ptr_skel; + uintptr_t ptr_parts; + int16_t numparts; + int16_t nummatrices; + uint32_t scale; + uint16_t rwdatalen; + uint16_t numtexconfigs; + uintptr_t ptr_texconfigs; +}; + +struct src_modelnode { + uint16_t type; + uint32_t ptr_rodata; + uint32_t ptr_parent; + uint32_t ptr_next; + uint32_t ptr_prev; + uint32_t ptr_child; +}; + +struct dst_modelnode { + uint16_t type; + uintptr_t ptr_rodata; + uintptr_t ptr_parent; + uintptr_t ptr_next; + uintptr_t ptr_prev; + uintptr_t ptr_child; +}; + +struct generic_rodata_chrinfo { + uint16_t animpart; + int16_t mtxindex; + uint32_t unk04; + uint16_t rwdataindex; +}; + +struct generic_rodata_position { + uint32_t pos[3]; + uint16_t part; + int16_t mtxindexes[3]; + uint32_t drawdist; +}; + +struct src_rodata_gundl { + uint32_t ptr_opagdl; + uint32_t ptr_xlugdl; + uint32_t ptr_baseaddr; + uint32_t ptr_vertices; + int16_t numvertices; + int16_t unk12; +}; + +struct dst_rodata_gundl { + uintptr_t ptr_opagdl; + uintptr_t ptr_xlugdl; + uintptr_t ptr_baseaddr; + uintptr_t ptr_vertices; + int16_t numvertices; + int16_t unk12; +}; + +struct src_rodata_distance { + uint32_t near; + uint32_t far; + uint32_t ptr_target; + uint16_t rwdataindex; +}; + +struct dst_rodata_distance { + uint32_t near; + uint32_t far; + uintptr_t ptr_target; + uint16_t rwdataindex; +}; + +struct src_rodata_reorder { + uint32_t unk00; + uint32_t unk04; + uint32_t unk08; + uint32_t unk0c[3]; + uint32_t ptr_node_unk18; + uint32_t ptr_node_unk1c; + int16_t side; + uint16_t rwdataindex; +}; + +struct dst_rodata_reorder { + uint32_t unk00; + uint32_t unk04; + uint32_t unk08; + uint32_t unk0c[3]; + uintptr_t ptr_node_unk18; + uintptr_t ptr_node_unk1c; + int16_t side; + uint16_t rwdataindex; +}; + +struct generic_rodata_bbox { + int32_t hitpart; + uint32_t bbox[6]; +}; + +struct src_rodata_chrgunfire { + uint32_t pos[3]; + uint32_t dim[3]; + uint32_t ptr_texture; + uint32_t unk1c; + uint16_t rwdataindex; + uint32_t ptr_baseaddr; +}; + +struct dst_rodata_chrgunfire { + uint32_t pos[3]; + uint32_t dim[3]; + uintptr_t ptr_texture; + uint32_t unk1c; + uint16_t rwdataindex; + uintptr_t ptr_baseaddr; +}; + +struct src_rodata_type11 { + uint32_t unk00; + uint32_t unk04; + uint32_t unk08; + uint32_t unk0c; + uint32_t unk10; + uint32_t ptr_unk14; +}; + +struct dst_rodata_type11 { + uint32_t unk00; + uint32_t unk04; + uint32_t unk08; + uint32_t unk0c; + uint32_t unk10; + uintptr_t ptr_unk14; +}; + +struct src_rodata_toggle { + uint32_t ptr_target; + uint16_t rwdataindex; +}; + +struct dst_rodata_toggle { + uintptr_t ptr_target; + uint16_t rwdataindex; +}; + +struct generic_rodata_positionheld { + uint32_t pos[3]; + int16_t mtxindex; + uint32_t unk10; +}; + +struct src_rodata_stargunfire { + uint32_t unk00; + uint32_t ptr_vertices; + uint32_t ptr_gdl; + uint32_t ptr_baseaddr; +}; + +struct dst_rodata_stargunfire { + uint32_t unk00; + uintptr_t ptr_vertices; + uintptr_t ptr_gdl; + uintptr_t ptr_baseaddr; +}; + +struct generic_rodata_headspot { + uint16_t rwdataindex; +}; + +struct src_rodata_dl { + uint32_t ptr_opagdl; + uint32_t ptr_xlugdl; + uint32_t ptr_colours; + uint32_t ptr_vertices; // colours follow this array + int16_t numvertices; + int16_t mcount; + uint16_t rwdataindex; + uint16_t numcolours; +}; + +struct dst_rodata_dl { + uintptr_t ptr_opagdl; + uintptr_t ptr_xlugdl; + uintptr_t ptr_colours; + uintptr_t ptr_vertices; // colours follow this array + int16_t numvertices; + int16_t mcount; + uint16_t rwdataindex; + uint16_t numcolours; +}; + +struct generic_rodata_type19 { + uint32_t numvertices; + uint32_t vertices[3]; +}; + +struct src_texconfig { + uint32_t ptr; + uint8_t width; + uint8_t height; + uint8_t level; + uint8_t format; + uint8_t depth; + uint8_t s; + uint8_t t; + uint8_t unk0b; +}; + +struct dst_texconfig { + uintptr_t ptr; + uint8_t width; + uint8_t height; + uint8_t level; + uint8_t format; + uint8_t depth; + uint8_t s; + uint8_t t; + uint8_t unk0b; +}; + +static struct marker *find_marker(uint32_t src_offset) +{ + for (int i = 0; i < m_NumMarkers; i++) { + if (m_Markers[i].src_offset == src_offset) { + return &m_Markers[i]; + } + } + + return NULL; +} + +static void set_marker(uint32_t src_offset, enum contenttype type, uint32_t parent_src_offset) +{ + if (src_offset == 0) { + return; + } + + src_offset &= 0x00ffffff; + + if (find_marker(src_offset)) { + return; + } + + if (m_NumMarkers >= ARRAYCOUNT(m_Markers)) { + fprintf(stderr, "Marker limit exceeded\n"); + exit(EXIT_FAILURE); + } + + m_Markers[m_NumMarkers].src_offset = src_offset; + m_Markers[m_NumMarkers].type = type; + m_Markers[m_NumMarkers].parent_src_offset = parent_src_offset; + m_NumMarkers++; +} + +enum contenttype m_NodeTypeToContentType[] = { + /*0x00*/ -1, + /*0x01*/ CT_RODATA_CHRINFO, + /*0x02*/ CT_RODATA_POSITION, + /*0x03*/ -1, + /*0x04*/ CT_RODATA_GUNDL, + /*0x05*/ -1, + /*0x06*/ -1, + /*0x07*/ -1, + /*0x08*/ CT_RODATA_DISTANCE, + /*0x09*/ CT_RODATA_REORDER, + /*0x0a*/ CT_RODATA_BBOX, + /*0x0b*/ -1, + /*0x0c*/ CT_RODATA_CHRGUNFIRE, + /*0x0d*/ -1, + /*0x0e*/ -1, + /*0x0f*/ -1, + /*0x10*/ -1, + /*0x11*/ CT_RODATA_11, + /*0x12*/ CT_RODATA_TOGGLE, + /*0x13*/ -1, + /*0x14*/ -1, + /*0x15*/ CT_RODATA_POSITIONHELD, + /*0x16*/ CT_RODATA_STARGUNFIRE, + /*0x17*/ CT_RODATA_HEADSPOT, + /*0x18*/ CT_RODATA_DL, + /*0x19*/ CT_RODATA_19, +}; + +static void populate_markers(uint8_t *src) +{ + m_NumMarkers = 0; + + set_marker(0x05000000, CT_MODELDEF, 0); + + for (int i = 0; i < m_NumMarkers; i++) { + struct marker *marker = &m_Markers[i]; + void *src_thing = &src[marker->src_offset]; + + switch (marker->type) { + case CT_MODELDEF: + struct src_modeldef *src_modeldef = src_thing; + int num_texconfigs = srctoh16(src_modeldef->numtexconfigs); + uint32_t texconfigpos = srctoh32(src_modeldef->ptr_texconfigs); + set_marker(srctoh32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); + + for (int i = 0; i < num_texconfigs; i++) { + set_marker(texconfigpos + sizeof(struct src_texconfig) * i, CT_TEXCONFIG, marker->src_offset); + } + break; + case CT_NODE: + struct src_modelnode *src_node = src_thing; + uint32_t node_type = srctoh16(src_node->type) & 0xff; + set_marker(srctoh32(src_node->ptr_rodata), m_NodeTypeToContentType[node_type], marker->src_offset); + set_marker(srctoh32(src_node->ptr_parent), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_node->ptr_next), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_node->ptr_prev), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_node->ptr_child), CT_NODE, marker->src_offset); + break; + case CT_TEXCONFIG: + struct src_texconfig *src_texconfig = src_thing; + if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { + set_marker(srctoh32(src_texconfig->ptr), CT_TEXDATA, marker->src_offset); + } + break; + case CT_PARTS: + struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + uint32_t *src_parts = (uint32_t *) src_thing; + int num_parts = srctoh16(src_modeldef2->numparts); + + for (int i = 0; i < num_parts; i++) { + set_marker(srctoh32(src_parts[i]), CT_NODE, marker->src_offset); + } + break; + case CT_RODATA_CHRINFO: + break; + case CT_RODATA_POSITION: + break; + case CT_RODATA_GUNDL: + struct src_rodata_gundl *src_gundl = src_thing; + set_marker(srctoh32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); + set_marker(srctoh32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); + set_marker(srctoh32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); + break; + case CT_RODATA_DISTANCE: + struct src_rodata_distance *src_dist = src_thing; + set_marker(srctoh32(src_dist->ptr_target), CT_NODE, marker->src_offset); + break; + case CT_RODATA_REORDER: + struct src_rodata_reorder *src_reorder = src_thing; + set_marker(srctoh32(src_reorder->ptr_node_unk18), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_reorder->ptr_node_unk1c), CT_NODE, marker->src_offset); + break; + case CT_RODATA_CHRGUNFIRE: + struct src_rodata_chrgunfire *src_chrgunfire = src_thing; + set_marker(srctoh32(src_chrgunfire->ptr_texture), CT_TEXCONFIG, marker->src_offset); + break; + case CT_RODATA_TOGGLE: + struct src_rodata_toggle *src_toggle = src_thing; + set_marker(srctoh32(src_toggle->ptr_target), CT_NODE, marker->src_offset); + break; + case CT_RODATA_STARGUNFIRE: + struct src_rodata_stargunfire *src_stargunfire = src_thing; + set_marker(srctoh32(src_stargunfire->ptr_vertices), CT_VTXCOL, marker->src_offset); + set_marker(srctoh32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); + break; + case CT_RODATA_DL: + struct src_rodata_dl *src_dl = src_thing; + set_marker(srctoh32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); + set_marker(srctoh32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); + set_marker(srctoh32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); + set_marker(srctoh32(src_dl->ptr_vertices), CT_VTXCOL, marker->src_offset); + break; + case CT_TEXDATA: + case CT_VTXCOL: + case CT_GDL: + case CT_RODATA_BBOX: + case CT_RODATA_11: + case CT_RODATA_POSITIONHELD: + case CT_RODATA_HEADSPOT: + case CT_RODATA_19: + break; + } + } +} + +static void sort_markers(void) +{ + for (int i = 0; i < m_NumMarkers - 1; i++) { + uint32_t min_offset = 0xffffffff; + int min_index = -1; + + for (int j = i + 1; j < m_NumMarkers; j++) { + if (m_Markers[j].src_offset < min_offset) { + min_offset = m_Markers[j].src_offset; + min_index = j; + } + } + + if (min_index >= 0 && m_Markers[min_index].src_offset < m_Markers[i].src_offset) { + struct marker tmp = m_Markers[i]; + m_Markers[i] = m_Markers[min_index]; + m_Markers[min_index] = tmp; + } + } +} + +static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_len) +{ + uint32_t dstpos = 0; + + for (int i = 0; i < m_NumMarkers; i++) { + struct marker *marker = &m_Markers[i]; + void *src_thing = &src[marker->src_offset]; + uint32_t src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; + uint32_t src_len = src_end - marker->src_offset; + + dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].before); + + marker->dst_offset = dstpos; + void *dst_thing = &dst[dstpos]; + + switch (marker->type) { + case CT_MODELDEF: + struct src_modeldef *src_modeldef = src_thing; + struct dst_modeldef *dst_modeldef = dst_thing; + dst_modeldef->ptr_skel = srctodst32(src_modeldef->ptr_skel); + dst_modeldef->numparts = srctodst16(src_modeldef->numparts); + dst_modeldef->nummatrices = srctodst16(src_modeldef->nummatrices); + dst_modeldef->scale = srctodst32(src_modeldef->scale); + dst_modeldef->rwdatalen = srctodst16(src_modeldef->rwdatalen); + dst_modeldef->numtexconfigs = srctodst16(src_modeldef->numtexconfigs); + dstpos += sizeof(*dst_modeldef); + break; + case CT_NODE: + struct src_modelnode *src_node = src_thing; + struct dst_modelnode *dst_node = dst_thing; + dst_node->type = srctodst16(src_node->type); + dstpos += sizeof(*dst_node); + break; + case CT_TEXCONFIG: + struct src_texconfig *src_texconfig = src_thing; + struct dst_texconfig *dst_texconfig = dst_thing; + + while (src_len >= sizeof(*src_texconfig)) { + if ((srctoh32(src_texconfig->ptr) & 0xff000000) != 0x05000000) { + dst_texconfig->ptr = srctodst32(src_texconfig->ptr); + } + + dst_texconfig->width = src_texconfig->width; + dst_texconfig->height = src_texconfig->height; + dst_texconfig->level = src_texconfig->level; + dst_texconfig->format = src_texconfig->format; + dst_texconfig->depth = src_texconfig->depth; + dst_texconfig->s = src_texconfig->s; + dst_texconfig->t = src_texconfig->t; + dst_texconfig->unk0b = src_texconfig->unk0b; + + dstpos += sizeof(*dst_texconfig); + src_len -= sizeof(*src_texconfig); + src_texconfig++; + dst_texconfig++; + } + break; + case CT_TEXDATA: + memcpy(dst_thing, src_thing, src_len); + dstpos += src_len; + break; + case CT_PARTS: + struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + uint32_t *src_parts = (uint32_t *) src_thing; + uintptr_t *dst_parts = (uintptr_t *) dst_thing; + int num_parts = srctoh16(src_modeldef2->numparts); + uint16_t *src_nums = (uint16_t *) &src_parts[num_parts]; + uint16_t *dst_nums = (uint16_t *) &dst_parts[num_parts]; + + for (int i = 0; i < num_parts; i++) { + dst_nums[i] = srctodst16(src_nums[i]); + } + dstpos += num_parts * sizeof(uintptr_t) + num_parts * sizeof(uint16_t); + if (num_parts) { + dstpos = ALIGN8(dstpos); + } + break; + case CT_VTXCOL: + memcpy(dst_thing, src_thing, src_len); + dstpos += src_len; + break; + case CT_GDL: + struct marker *parent = find_marker(marker->parent_src_offset); + uint32_t src_vtx; + uint32_t dst_vtx; + + if (parent->type == CT_RODATA_GUNDL) { + struct src_rodata_gundl *src_rodata = (struct src_rodata_gundl *) &src[parent->src_offset]; + struct dst_rodata_gundl *dst_rodata = (struct dst_rodata_gundl *) &dst[parent->dst_offset]; + src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + } else if (parent->type == CT_RODATA_STARGUNFIRE) { + struct src_rodata_stargunfire *src_rodata = (struct src_rodata_stargunfire *) &src[parent->src_offset]; + struct dst_rodata_stargunfire *dst_rodata = (struct dst_rodata_stargunfire *) &dst[parent->dst_offset]; + src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + } else if (parent->type == CT_RODATA_DL) { + struct src_rodata_dl *src_rodata = (struct src_rodata_dl *) &src[parent->src_offset]; + struct dst_rodata_dl *dst_rodata = (struct dst_rodata_dl *) &dst[parent->dst_offset]; + src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + } + + gbi_set_vtx(src_vtx, dst_vtx); + gbi_set_segment(0x04, dst_vtx); + gbi_set_segment(0x05, 0); + dstpos = gbi_convert_gdl(dst, dstpos, src, marker->src_offset); + break; + case CT_RODATA_CHRINFO: + struct generic_rodata_chrinfo *src_chrinfo = src_thing; + struct generic_rodata_chrinfo *dst_chrinfo = dst_thing; + dst_chrinfo->animpart = srctodst16(src_chrinfo->animpart); + dst_chrinfo->mtxindex = srctodst16(src_chrinfo->mtxindex); + dst_chrinfo->unk04 = srctodst32(src_chrinfo->unk04); + dst_chrinfo->rwdataindex = srctodst16(src_chrinfo->rwdataindex); + dstpos += sizeof(*dst_chrinfo); + break; + case CT_RODATA_POSITION: + struct generic_rodata_position *src_position = src_thing; + struct generic_rodata_position *dst_position = dst_thing; + dst_position->pos[0] = srctodst32(src_position->pos[0]); + dst_position->pos[1] = srctodst32(src_position->pos[1]); + dst_position->pos[2] = srctodst32(src_position->pos[2]); + dst_position->part = srctodst16(src_position->part); + dst_position->mtxindexes[0] = srctodst16(src_position->mtxindexes[0]); + dst_position->mtxindexes[1] = srctodst16(src_position->mtxindexes[1]); + dst_position->mtxindexes[2] = srctodst16(src_position->mtxindexes[2]); + dst_position->drawdist = srctodst32(src_position->drawdist); + dstpos += sizeof(*dst_position); + break; + case CT_RODATA_GUNDL: + struct src_rodata_gundl *src_gundl = src_thing; + struct dst_rodata_gundl *dst_gundl = dst_thing; + dst_gundl->ptr_vertices = 0; + dst_gundl->numvertices = srctodst16(src_gundl->numvertices); + dst_gundl->unk12 = srctodst16(src_gundl->unk12); + dstpos += sizeof(*dst_gundl); + break; + case CT_RODATA_DISTANCE: + struct src_rodata_distance *src_dist = src_thing; + struct dst_rodata_distance *dst_dist = dst_thing; + dst_dist->near = srctodst32(src_dist->near); + dst_dist->far = srctodst32(src_dist->far); + dst_dist->rwdataindex = srctodst16(src_dist->rwdataindex); + dstpos += sizeof(*dst_dist); + break; + case CT_RODATA_REORDER: + struct src_rodata_reorder *src_reorder = src_thing; + struct dst_rodata_reorder *dst_reorder = dst_thing; + dst_reorder->unk00 = srctodst32(src_reorder->unk00); + dst_reorder->unk04 = srctodst32(src_reorder->unk04); + dst_reorder->unk08 = srctodst32(src_reorder->unk08); + dst_reorder->unk0c[0] = srctodst32(src_reorder->unk0c[0]); + dst_reorder->unk0c[1] = srctodst32(src_reorder->unk0c[1]); + dst_reorder->unk0c[2] = srctodst32(src_reorder->unk0c[2]); + dst_reorder->side = srctodst16(src_reorder->side); + dst_reorder->rwdataindex = srctodst16(src_reorder->rwdataindex); + dstpos += sizeof(*dst_reorder); + break; + case CT_RODATA_BBOX: + struct generic_rodata_bbox *src_bbox = src_thing; + struct generic_rodata_bbox *dst_bbox = dst_thing; + dst_bbox->hitpart = srctodst32(src_bbox->hitpart); + dst_bbox->bbox[0] = srctodst32(src_bbox->bbox[0]); + dst_bbox->bbox[1] = srctodst32(src_bbox->bbox[1]); + dst_bbox->bbox[2] = srctodst32(src_bbox->bbox[2]); + dst_bbox->bbox[3] = srctodst32(src_bbox->bbox[3]); + dst_bbox->bbox[4] = srctodst32(src_bbox->bbox[4]); + dst_bbox->bbox[5] = srctodst32(src_bbox->bbox[5]); + dstpos += sizeof(*dst_bbox); + break; + case CT_RODATA_CHRGUNFIRE: + struct src_rodata_chrgunfire *src_chrgunfire = src_thing; + struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; + dst_chrgunfire->pos[0] = srctodst32(src_chrgunfire->pos[0]); + dst_chrgunfire->pos[1] = srctodst32(src_chrgunfire->pos[1]); + dst_chrgunfire->pos[2] = srctodst32(src_chrgunfire->pos[2]); + dst_chrgunfire->dim[0] = srctodst32(src_chrgunfire->dim[0]); + dst_chrgunfire->dim[1] = srctodst32(src_chrgunfire->dim[1]); + dst_chrgunfire->dim[2] = srctodst32(src_chrgunfire->dim[2]); + dst_chrgunfire->unk1c = srctodst32(src_chrgunfire->unk1c); + dst_chrgunfire->rwdataindex = srctodst16(src_chrgunfire->rwdataindex); + dst_chrgunfire->ptr_baseaddr = 0; + dstpos += sizeof(*dst_chrgunfire); + break; + case CT_RODATA_11: + struct src_rodata_type11 *src_type11 = src_thing; + struct dst_rodata_type11 *dst_type11 = dst_thing; + dst_type11->unk00 = srctodst32(src_type11->unk00); + dst_type11->unk04 = srctodst32(src_type11->unk04); + dst_type11->unk08 = srctodst32(src_type11->unk08); + dst_type11->unk0c = srctodst32(src_type11->unk0c); + dst_type11->unk10 = srctodst32(src_type11->unk10); + dst_type11->ptr_unk14 = srctodst32(src_type11->ptr_unk14); // Not read by game engine + dstpos += sizeof(*dst_type11); + break; + case CT_RODATA_TOGGLE: + struct src_rodata_toggle *src_toggle = src_thing; + struct dst_rodata_toggle *dst_toggle = dst_thing; + dst_toggle->rwdataindex = srctodst16(src_toggle->rwdataindex); + dstpos += sizeof(*dst_toggle); + break; + case CT_RODATA_POSITIONHELD: + struct generic_rodata_positionheld *src_posheld = src_thing; + struct generic_rodata_positionheld *dst_posheld = dst_thing; + dst_posheld->pos[0] = srctodst32(src_posheld->pos[0]); + dst_posheld->pos[1] = srctodst32(src_posheld->pos[1]); + dst_posheld->pos[2] = srctodst32(src_posheld->pos[2]); + dst_posheld->mtxindex = srctodst16(src_posheld->mtxindex); + dst_posheld->unk10 = srctodst32(src_posheld->unk10); + dstpos += sizeof(*dst_posheld); + break; + case CT_RODATA_STARGUNFIRE: + struct src_rodata_stargunfire *src_stargunfire = src_thing; + struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; + dst_stargunfire->unk00 = srctodst32(src_stargunfire->unk00); + dstpos += sizeof(*dst_stargunfire); + break; + case CT_RODATA_HEADSPOT: + struct generic_rodata_headspot *src_headspot = src_thing; + struct generic_rodata_headspot *dst_headspot = dst_thing; + dst_headspot->rwdataindex = srctodst16(src_headspot->rwdataindex); + dstpos += sizeof(*dst_headspot); + break; + case CT_RODATA_DL: + struct src_rodata_dl *src_dl = src_thing; + struct dst_rodata_dl *dst_dl = dst_thing; + dst_dl->numvertices = srctodst16(src_dl->numvertices); + dst_dl->mcount = srctodst16(src_dl->mcount); + dst_dl->rwdataindex = srctodst16(src_dl->rwdataindex); + dst_dl->numcolours = srctodst16(src_dl->numcolours); + dstpos += sizeof(*dst_dl); + break; + case CT_RODATA_19: + struct generic_rodata_type19 *src_type19 = src_thing; + struct generic_rodata_type19 *dst_type19 = dst_thing; + uint32_t *src_vertices = src_thing + sizeof(uint32_t); + uint32_t *dst_vertices = dst_thing + sizeof(uint32_t); + int num_vertices = srctoh32(src_type19->numvertices); + + dst_type19->numvertices = htodst32(num_vertices); + dstpos += sizeof(uint32_t); + + for (int i = 0; i < num_vertices; i++) { + dst_vertices[i * 3 + 0] = srctodst32(src_vertices[i * 3 + 0]); + dst_vertices[i * 3 + 1] = srctodst32(src_vertices[i * 3 + 1]); + dst_vertices[i * 3 + 2] = srctodst32(src_vertices[i * 3 + 2]); + dstpos += sizeof(uint32_t) * 3; + } + break; + } + + dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].after); + } + + return dstpos; +} + +static uint32_t resolve_pointer(uint32_t src_offset) +{ + if (src_offset == 0) { + return 0; + } + + struct marker *marker = find_marker(src_offset & 0x00ffffff); + return marker ? (0x05000000 | marker->dst_offset) : 0; +} + +static void relink_pointers(uint8_t *dst, uint8_t *src) +{ + for (int i = 0; i < m_NumMarkers; i++) { + struct marker *marker = &m_Markers[i]; + void *src_thing = &src[marker->src_offset]; + void *dst_thing = &dst[marker->dst_offset]; + + switch (marker->type) { + case CT_MODELDEF: + struct src_modeldef *src_modeldef = src_thing; + struct dst_modeldef *dst_modeldef = dst_thing; + dst_modeldef->ptr_rootnode = htodst32(resolve_pointer(srctoh32(src_modeldef->ptr_rootnode))); + dst_modeldef->ptr_parts = htodst32(resolve_pointer(srctoh32(src_modeldef->ptr_parts))); + dst_modeldef->ptr_texconfigs = htodst32(resolve_pointer(srctoh32(src_modeldef->ptr_texconfigs))); + break; + case CT_NODE: + struct src_modelnode *src_node = src_thing; + struct dst_modelnode *dst_node = dst_thing; + dst_node->ptr_rodata = htodst32(resolve_pointer(srctoh32(src_node->ptr_rodata))); + dst_node->ptr_parent = htodst32(resolve_pointer(srctoh32(src_node->ptr_parent))); + dst_node->ptr_next = htodst32(resolve_pointer(srctoh32(src_node->ptr_next))); + dst_node->ptr_prev = htodst32(resolve_pointer(srctoh32(src_node->ptr_prev))); + dst_node->ptr_child = htodst32(resolve_pointer(srctoh32(src_node->ptr_child))); + break; + case CT_TEXCONFIG: + struct src_texconfig *src_texconfig = src_thing; + struct dst_texconfig *dst_texconfig = dst_thing; + if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { + dst_texconfig->ptr = htodst32(resolve_pointer(srctoh32(src_texconfig->ptr))); + } + break; + case CT_PARTS: + struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + uint32_t *src_parts = (uint32_t *) src_thing; + uintptr_t *dst_parts = (uintptr_t *) dst_thing; + int num_parts = srctoh16(src_modeldef2->numparts); + + for (int i = 0; i < num_parts; i++) { + dst_parts[i] = htodst32(resolve_pointer(srctoh32(src_parts[i]))); + } + break; + case CT_RODATA_CHRINFO: + break; + case CT_RODATA_POSITION: + break; + case CT_RODATA_GUNDL: + struct src_rodata_gundl *src_gundl = src_thing; + struct dst_rodata_gundl *dst_gundl = dst_thing; + dst_gundl->ptr_opagdl = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_opagdl))); + dst_gundl->ptr_xlugdl = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_xlugdl))); + dst_gundl->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_vertices))); + break; + case CT_RODATA_DISTANCE: + struct src_rodata_distance *src_dist = src_thing; + struct dst_rodata_distance *dst_dist = dst_thing; + dst_dist->ptr_target = htodst32(resolve_pointer(srctoh32(src_dist->ptr_target))); + break; + case CT_RODATA_REORDER: + struct src_rodata_reorder *src_reorder = src_thing; + struct dst_rodata_reorder *dst_reorder = dst_thing; + dst_reorder->ptr_node_unk18 = htodst32(resolve_pointer(srctoh32(src_reorder->ptr_node_unk18))); + dst_reorder->ptr_node_unk1c = htodst32(resolve_pointer(srctoh32(src_reorder->ptr_node_unk1c))); + break; + case CT_RODATA_CHRGUNFIRE: + struct src_rodata_chrgunfire *src_chrgunfire = src_thing; + struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; + dst_chrgunfire->ptr_texture = htodst32(resolve_pointer(srctoh32(src_chrgunfire->ptr_texture))); + break; + case CT_RODATA_TOGGLE: + struct src_rodata_toggle *src_toggle = src_thing; + struct dst_rodata_toggle *dst_toggle = dst_thing; + dst_toggle->ptr_target = htodst32(resolve_pointer(srctoh32(src_toggle->ptr_target))); + break; + case CT_RODATA_STARGUNFIRE: + struct src_rodata_stargunfire *src_stargunfire = src_thing; + struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; + dst_stargunfire->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_stargunfire->ptr_vertices))); + dst_stargunfire->ptr_gdl = htodst32(resolve_pointer(srctoh32(src_stargunfire->ptr_gdl))); + break; + case CT_RODATA_DL: + struct src_rodata_dl *src_dl = src_thing; + struct dst_rodata_dl *dst_dl = dst_thing; + dst_dl->ptr_opagdl = htodst32(resolve_pointer(srctoh32(src_dl->ptr_opagdl))); + dst_dl->ptr_xlugdl = htodst32(resolve_pointer(srctoh32(src_dl->ptr_xlugdl))); + dst_dl->ptr_colours = htodst32(resolve_pointer(srctoh32(src_dl->ptr_colours))); + dst_dl->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_dl->ptr_vertices))); + break; + case CT_TEXDATA: + case CT_VTXCOL: + case CT_GDL: + case CT_RODATA_BBOX: + case CT_RODATA_11: + case CT_RODATA_POSITIONHELD: + case CT_RODATA_HEADSPOT: + case CT_RODATA_19: + break; + } + } +} + +int calc_align(uint32_t value) +{ + if ((value % 16) == 0) { + return 16; + } else if ((value % 8) == 0) { + return 8; + } else if ((value % 4) == 0) { + return 4; + } else if ((value % 2) == 0) { + return 2; + } else { + return 1; + } +} + +static int convert_model(uint8_t *dst, uint8_t *src, uint32_t srclen) +{ + uint32_t dstpos; + + populate_markers(src); + sort_markers(); + + dstpos = convert_content(dst, src, srclen); + relink_pointers(dst, src); + + return dstpos; +} + +void extract_file_model(char *filename, uint32_t romoffset, size_t len) +{ + // Unzip it + size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); + uint8_t *src = malloc(infsize); + + int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); + + if (ret < 0) { + fprintf(stderr, "%s: Unable to inflate file: %d\n", filename, ret); + exit(EXIT_FAILURE); + } + + // Convert it + uint8_t *dst = calloc(1, infsize * 4); + + int dstpos = convert_model(dst, src, infsize); + + if (dstpos > infsize * 2) { + fprintf(stderr, "%s: overflow\n", filename); + exit(EXIT_FAILURE); + } + + // Zip it + uint8_t *zipped = calloc(1, dstpos); + size_t ziplen = dstpos; + + ret = rzip_deflate(zipped, &ziplen, dst, dstpos); + + if (ret < 0) { + fprintf(stderr, "%s: Unable to compress file: %d\n", filename, ret); + exit(EXIT_FAILURE); + } + + ziplen = ALIGN16(ziplen); + + // Write it + char outfilename[1024]; + sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(zipped, ziplen, 1, fp); + fclose(fp); + + free(zipped); + free(dst); + free(src); +} diff --git a/port/pdextract/ext_file_pads.c b/port/pdextract/ext_file_pads.c new file mode 100644 index 000000000..bfb77cc1f --- /dev/null +++ b/port/pdextract/ext_file_pads.c @@ -0,0 +1,357 @@ +#include +#include +#include +#include "common.h" + +#define PADFLAG_INTPOS 0x0001 +#define PADFLAG_UPALIGNTOX 0x0002 +#define PADFLAG_UPALIGNTOY 0x0004 +#define PADFLAG_UPALIGNTOZ 0x0008 +#define PADFLAG_UPALIGNINVERT 0x0010 +#define PADFLAG_LOOKALIGNTOX 0x0020 +#define PADFLAG_LOOKALIGNTOY 0x0040 +#define PADFLAG_LOOKALIGNTOZ 0x0080 +#define PADFLAG_LOOKALIGNINVERT 0x0100 +#define PADFLAG_HASBBOXDATA 0x0200 + +struct n64_header { + int32_t num_pads; + int32_t num_covers; + uint32_t ptr_waypoints; + uint32_t ptr_waygroups; + uint32_t ptr_cover; +}; + +struct host_header { + int32_t num_pads; + int32_t num_covers; + uintptr_t ptr_waypoints; + uintptr_t ptr_waygroups; + uintptr_t ptr_cover; +}; + +struct padheader { + uint32_t flags : 18; + uint32_t room : 10; + uint32_t liftnum : 4; +}; + +struct n64_waypoint { + int32_t padnum; + uint32_t ptr_neighbours; + int32_t groupnum; + int32_t step; +}; + +struct host_waypoint { + int32_t padnum; + uintptr_t ptr_neighbours; + int32_t groupnum; + int32_t step; +}; + +struct n64_waygroup { + uint32_t ptr_neighbours; + uint32_t ptr_waypoints; + int32_t step; +}; + +struct host_waygroup { + uintptr_t ptr_neighbours; + uintptr_t ptr_waypoints; + int32_t step; +}; + +struct coverdefinition { + uint32_t pos[3]; + uint32_t dir[3]; + uint16_t flags; + uint16_t unk1a; +}; + +static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int num_pads) +{ + uint16_t *src_offsets = (uint16_t *) &src[srcpos]; + uint16_t *dst_offsets = (uint16_t *) &dst[dstpos]; + + dstpos += num_pads * sizeof(uint16_t); + + for (int i = 0; i < num_pads; i++) { + dstpos = ALIGN4(dstpos); + srcpos = srctoh16(src_offsets[i]); + + dst_offsets[i] = htodst16(dstpos); + + // Header + uint32_t n64_padheader = srctoh32(*(uint32_t *) &src[srcpos]); + struct padheader *host_padheader = (struct padheader *) &dst[dstpos]; + uint32_t flags = (n64_padheader >> 14) & 0x3ffff; + +#ifdef FORCE_BE32 + *(uint32_t *) host_padheader = htodst32(n64_padheader); +#else + host_padheader->flags = flags; + host_padheader->room = (n64_padheader >> 4) & 0x3ff; + host_padheader->liftnum = n64_padheader & 0xf; +#endif + + srcpos += sizeof(struct padheader); + dstpos += sizeof(struct padheader); + + // Position + if (flags & PADFLAG_INTPOS) { + int16_t *srcptr = (int16_t *) &src[srcpos]; + int16_t *dstptr = (int16_t *) &dst[dstpos]; + + dstptr[0] = srctodst16(srcptr[0]); + dstptr[1] = srctodst16(srcptr[1]); + dstptr[2] = srctodst16(srcptr[2]); + + srcpos += 8; + dstpos += 8; + } else { + uint32_t *srcptr = (uint32_t *) &src[srcpos]; + uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + + dstptr[0] = srctodst32(srcptr[0]); + dstptr[1] = srctodst32(srcptr[1]); + dstptr[2] = srctodst32(srcptr[2]); + + srcpos += 12; + dstpos += 12; + } + + // Up + if ((flags & (PADFLAG_UPALIGNTOX | PADFLAG_UPALIGNTOY | PADFLAG_UPALIGNTOZ)) == 0) { + uint32_t *srcptr = (uint32_t *) &src[srcpos]; + uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + + dstptr[0] = srctodst32(srcptr[0]); + dstptr[1] = srctodst32(srcptr[1]); + dstptr[2] = srctodst32(srcptr[2]); + + srcpos += 12; + dstpos += 12; + } + + // Look + if ((flags & (PADFLAG_LOOKALIGNTOX | PADFLAG_LOOKALIGNTOY | PADFLAG_LOOKALIGNTOZ)) == 0) { + uint32_t *srcptr = (uint32_t *) &src[srcpos]; + uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + + dstptr[0] = srctodst32(srcptr[0]); + dstptr[1] = srctodst32(srcptr[1]); + dstptr[2] = srctodst32(srcptr[2]); + + srcpos += 12; + dstpos += 12; + } + + // Bbox + if (flags & PADFLAG_HASBBOXDATA) { + uint32_t *srcptr = (uint32_t *) &src[srcpos]; + uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + + dstptr[0] = srctodst32(srcptr[0]); + dstptr[1] = srctodst32(srcptr[1]); + dstptr[2] = srctodst32(srcptr[2]); + dstptr[3] = srctodst32(srcptr[3]); + dstptr[4] = srctodst32(srcptr[4]); + dstptr[5] = srctodst32(srcptr[5]); + + srcpos += 4 * 6; + dstpos += 4 * 6; + } + } + + return dstpos; +} + +static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct n64_waypoint *n64_waypoints = (struct n64_waypoint *) &src[srcpos]; + struct host_waypoint *host_waypoints = (struct host_waypoint *) &dst[dstpos]; + int num_waypoints; + + for (num_waypoints = 0; n64_waypoints[num_waypoints].padnum != -1; num_waypoints++); + + dstpos += (num_waypoints + 1) * sizeof(struct host_waypoint); + + uint32_t *host_neighbours = (uint32_t *) &dst[dstpos]; + int n = 0; + + for (int i = 0; i < num_waypoints; i++) { + host_waypoints[i].padnum = srctodst32(n64_waypoints[i].padnum); + host_waypoints[i].ptr_neighbours = htodst32(dstpos); + host_waypoints[i].groupnum = srctodst32(n64_waypoints[i].groupnum); + host_waypoints[i].step = 0; + + uint32_t *n64_neighbours = (uint32_t *) &src[srctoh32(n64_waypoints[i].ptr_neighbours)]; + + for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { + host_neighbours[n++] = srctodst32(n64_neighbours[j]); + dstpos += 4; + } + + host_neighbours[n++] = 0xffffffff; + dstpos += 4; + } + + // Terminator + host_waypoints[num_waypoints].padnum = 0xffffffff; + host_waypoints[num_waypoints].ptr_neighbours = 0; + host_waypoints[num_waypoints].groupnum = 0; + host_waypoints[num_waypoints].step = 0; + + return dstpos; +} + +static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +{ + struct n64_waygroup *n64_waygroups = (struct n64_waygroup *) &src[srcpos]; + struct host_waygroup *host_waygroups = (struct host_waygroup *) &dst[dstpos]; + int num_waygroups; + + for (num_waygroups = 0; n64_waygroups[num_waygroups].ptr_neighbours != 0; num_waygroups++); + + dstpos += (num_waygroups + 1) * sizeof(struct host_waygroup); + + // Waygroups and child waypoints + uint32_t *host_waypoints = (uint32_t *) &dst[dstpos]; + int n = 0; + + for (int i = 0; i < num_waygroups; i++) { + host_waygroups[i].ptr_waypoints = htodst32(dstpos); + host_waygroups[i].step = 0; + + uint32_t *n64_waypoints = (uint32_t *) &src[srctoh32(n64_waygroups[i].ptr_waypoints)]; + + for (int j = 0; n64_waypoints[j] != 0xffffffff; j++) { + host_waypoints[n++] = srctodst32(n64_waypoints[j]); + dstpos += 4; + } + + host_waypoints[n++] = 0xffffffff; + dstpos += 4; + } + + // Terminator + host_waygroups[num_waygroups].ptr_neighbours = 0; + host_waygroups[num_waygroups].ptr_waypoints = 0; + host_waygroups[num_waygroups].step = 0; + + // Waygroup neighbours + uint32_t *host_neighbours = (uint32_t *) &dst[dstpos]; + n = 0; + + for (int i = 0; i < num_waygroups; i++) { + host_waygroups[i].ptr_neighbours = htodst32(dstpos); + + uint32_t *n64_neighbours = (uint32_t *) &src[srctoh32(n64_waygroups[i].ptr_neighbours)]; + + for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { + host_neighbours[n++] = srctodst32(n64_neighbours[j]); + dstpos += 4; + } + + host_neighbours[n++] = 0xffffffff; + dstpos += 4; + } + + return dstpos; +} + +static int convert_cover(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int num_covers) +{ + struct coverdefinition *n64_covers = (struct coverdefinition *) &src[srcpos]; + struct coverdefinition *host_covers = (struct coverdefinition *) &dst[dstpos]; + + for (int i = 0; i < num_covers; i++) { + host_covers[i].pos[0] = srctodst32(n64_covers[i].pos[0]); + host_covers[i].pos[1] = srctodst32(n64_covers[i].pos[1]); + host_covers[i].pos[2] = srctodst32(n64_covers[i].pos[2]); + host_covers[i].dir[0] = srctodst32(n64_covers[i].dir[0]); + host_covers[i].dir[1] = srctodst32(n64_covers[i].dir[1]); + host_covers[i].dir[2] = srctodst32(n64_covers[i].dir[2]); + host_covers[i].flags = srctodst16(n64_covers[i].flags); + host_covers[i].unk1a = srctodst16(n64_covers[i].unk1a); + } + + dstpos += num_covers * sizeof(struct coverdefinition); + + return dstpos; +} + +static int convert_binary(uint8_t *dst, uint8_t *src) +{ + int dstpos = 0; + struct n64_header *n64_header = (struct n64_header *) src; + struct host_header *host_header = (struct host_header *) dst; + + int num_pads = srctoh32(n64_header->num_pads); + int num_covers = srctoh32(n64_header->num_covers); + host_header->num_pads = htodst32(num_pads); + host_header->num_covers = htodst32(num_covers); + + dstpos += sizeof(struct host_header); + + // Pads + dstpos = convert_pads(dst, dstpos, src, sizeof(struct n64_header), num_pads); + + // Waypoints + host_header->ptr_waypoints = htodst32(dstpos); + dstpos = convert_waypoints(dst, dstpos, src, srctoh32(n64_header->ptr_waypoints)); + + // Waygroups + host_header->ptr_waygroups = htodst32(dstpos); + dstpos = convert_waygroups(dst, dstpos, src, srctoh32(n64_header->ptr_waygroups)); + + // Cover + host_header->ptr_cover = htodst32(dstpos); + dstpos = convert_cover(dst, dstpos, src, srctoh32(n64_header->ptr_cover), num_covers); + + return dstpos; +} + +void extract_file_pads(char *filename, uint32_t romoffset, size_t len) +{ + // Unzip it + size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); + uint8_t *src = malloc(infsize); + + int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); + + if (ret < 0) { + fprintf(stderr, "%s: Unable to inflate file: %d\n", filename, ret); + exit(EXIT_FAILURE); + } + + // Convert it + uint8_t *dst = calloc(1, infsize * 2); + int dstpos = convert_binary(dst, src); + + dstpos = ALIGN16(dstpos); + + // Zip it + uint8_t *zipped = calloc(1, dstpos); + size_t ziplen = dstpos; + + ret = rzip_deflate(zipped, &ziplen, dst, dstpos); + + if (ret < 0) { + fprintf(stderr, "%s: Unable to compress file: %d\n", filename, ret); + exit(EXIT_FAILURE); + } + + // Write it + char outfilename[1024]; + sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(zipped, ALIGN16(ziplen), 1, fp); + fclose(fp); + + free(src); + free(dst); + free(zipped); +} diff --git a/port/pdextract/ext_file_tiles.c b/port/pdextract/ext_file_tiles.c new file mode 100644 index 000000000..f074aa731 --- /dev/null +++ b/port/pdextract/ext_file_tiles.c @@ -0,0 +1,122 @@ +#include +#include +#include +#include "common.h" + +struct tile { + uint8_t type; + uint8_t numvertices; + uint16_t flags; + uint16_t floortype; + uint8_t xmin; + uint8_t ymin; + uint8_t zmin; + uint8_t xmax; + uint8_t ymax; + uint8_t zmax; + uint16_t floorcol; +}; + +void extract_file_tiles(char *filename, uint32_t romoffset, size_t len) +{ + // Unzip it + size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); + uint8_t *src = malloc(infsize); + + int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); + + if (ret < 0) { + fprintf(stderr, "%s: Unable to inflate file: %d\n", filename, ret); + exit(EXIT_FAILURE); + } + + int num_rooms = srctoh32(*(uint32_t *) src); + + size_t src_ptr_table_len = (num_rooms + 1) * 4; + size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(uintptr_t); + + uint32_t *src_offsets = (uint32_t *) &src[4]; + + size_t data_len = infsize - src_ptr_table_len - 4; + + uint8_t *dst = calloc(1, dst_ptr_table_len + data_len + 0x20); + + *(uint32_t *) dst = htodst32(num_rooms); + + uintptr_t *dst_offsets = (uintptr_t *) (dst + ALIGN(4, sizeof(uintptr_t))); + uint32_t cur_dst_offset = ALIGN(4, sizeof(uintptr_t)) + dst_ptr_table_len; + + uint32_t cur_src_offset = srctoh32(src_offsets[0]); + uint32_t end_src_offset = srctoh32(src_offsets[num_rooms]); + int room = 0; + + while (1) { + // Check if this is a new room and write the pointer offset if so + while (room < (num_rooms + 1) && srctoh32(src_offsets[room]) == cur_src_offset) { + dst_offsets[room] = htodst32(cur_dst_offset); + room++; + } + + if (cur_src_offset >= end_src_offset) { + break; + } + + // Write tile data + struct tile *n64tile = (struct tile *) &src[cur_src_offset]; + struct tile hosttile; + + hosttile.type = n64tile->type; + hosttile.numvertices = n64tile->numvertices; + hosttile.flags = srctodst16(n64tile->flags); + hosttile.floortype = srctodst16(n64tile->floortype); + hosttile.xmin = n64tile->xmin; + hosttile.ymin = n64tile->ymin; + hosttile.zmin = n64tile->zmin; + hosttile.xmax = n64tile->xmax; + hosttile.ymax = n64tile->ymax; + hosttile.zmax = n64tile->zmax; + hosttile.floorcol = srctodst16(n64tile->floorcol); + + memcpy(&dst[cur_dst_offset], &hosttile, sizeof(struct tile)); + + cur_dst_offset += sizeof(struct tile); + cur_src_offset += sizeof(struct tile); + + // Write tile vertices + for (int i = 0; i < hosttile.numvertices; i++) { + *(int16_t *) &dst[cur_dst_offset + 0] = srctodst16(*(int16_t *) &src[cur_src_offset + 0]); + *(int16_t *) &dst[cur_dst_offset + 2] = srctodst16(*(int16_t *) &src[cur_src_offset + 2]); + *(int16_t *) &dst[cur_dst_offset + 4] = srctodst16(*(int16_t *) &src[cur_src_offset + 4]); + cur_dst_offset += 6; + cur_src_offset += 6; + } + } + + cur_dst_offset = ALIGN16(cur_dst_offset); + + // Zip it + uint8_t *zipped = calloc(1, cur_dst_offset); + size_t ziplen = cur_dst_offset; + + ret = rzip_deflate(zipped, &ziplen, dst, cur_dst_offset); + + if (ret < 0) { + fprintf(stderr, "%s: Unable to compress file: %d\n", filename, ret); + exit(EXIT_FAILURE); + } + + ziplen = ALIGN16(ziplen); + + // Write it + char outfilename[1024]; + + sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(zipped, ziplen, 1, fp); + fclose(fp); + + free(zipped); + free(dst); + free(src); +} diff --git a/port/pdextract/ext_files.c b/port/pdextract/ext_files.c new file mode 100644 index 000000000..9f64e5031 --- /dev/null +++ b/port/pdextract/ext_files.c @@ -0,0 +1,100 @@ +#include +#include +#include +#include "common.h" + +void extract_file_audio(char *filename, uint32_t romoffset, size_t len); +void extract_file_bg(char *filename, uint32_t romoffset, size_t len); +void extract_file_lang(char *filename, uint32_t romoffset, size_t len); +void extract_file_model(char *filename, uint32_t romoffset, size_t len); +void extract_file_pads(char *filename, uint32_t romoffset, size_t len); +void extract_file_tiles(char *filename, uint32_t romoffset, size_t len); + +static void extract_file(int filenum, uint32_t romoffset, size_t len) +{ + uint32_t name_uint32_table = 0; + + switch (g_RomVersion) { + case ROMVERSION_NTSC10: + case ROMVERSION_NTSCFINAL: + name_uint32_table = 0x1d5ca00; + break; + case ROMVERSION_PALFINAL: + name_uint32_table = 0x1d534e0; + break; + case ROMVERSION_JPNFINAL: + name_uint32_table = 0x1d58a20; + break; + } + + uint32_t name_offset = name_uint32_table + srctoh32(*(uint32_t *) &g_Rom[name_uint32_table + filenum * 4]); + + char *filename = (char *) &g_Rom[name_offset]; + + if (strstr(filename, ".seg")) { + extract_file_bg(filename, romoffset, len); + } else if (strstr(filename, "padsZ")) { + extract_file_pads(filename, romoffset, len); + } else if (strstr(filename, "tilesZ")) { + extract_file_tiles(filename, romoffset, len); + } else if (filename[0] == 'A') { + extract_file_audio(filename, romoffset, len); + } else if (filename[0] == 'C' || filename[0] == 'G' || filename[0] == 'P') { + extract_file_model(filename, romoffset, len); + } else if (filename[0] == 'L') { + extract_file_lang(filename, romoffset, len); + } else if (filename[0] == 'U') { + // Setup file - don't extract + } else { + fprintf(stderr, "Unrecognised file type: '%s'\n", filename); + exit(EXIT_FAILURE); + } +} + +void extract_files(void) +{ + size_t infsize = rzip_get_infsize(&g_Rom[0x39850]); + uint8_t *data = malloc(infsize); + + int ret = rzip_inflate(data, infsize, &g_Rom[0x39850], infsize); + + if (ret < 0) { + fprintf(stderr, "Unable to inflate data segment: %d\n", ret); + exit(EXIT_FAILURE); + } + + uint32_t offset = 0; + + switch (g_RomVersion) { + case ROMVERSION_NTSC10: + case ROMVERSION_NTSCFINAL: + offset = 0x28080; + break; + case ROMVERSION_PALFINAL: + offset = 0x28910; + break; + case ROMVERSION_JPNFINAL: + offset = 0x28800; + break; + } + + uint32_t *offsets = (uint32_t *) &data[offset]; + int i = 0; + + while (1) { + uint32_t curr = srctoh32(offsets[i]); + uint32_t next = srctoh32(offsets[i + 1]); + + if (next == 0) { + break; + } + + if (curr) { + extract_file(i, curr, next - curr); + } + + i++; + } + + free(data); +} diff --git a/port/pdextract/ext_fonts.c b/port/pdextract/ext_fonts.c new file mode 100644 index 000000000..3ff07b494 --- /dev/null +++ b/port/pdextract/ext_fonts.c @@ -0,0 +1,157 @@ +#include +#include +#include +#include +#include +#include "common.h" + +struct n64fontchar { + uint8_t index; + int8_t baseline; + uint8_t height; + uint8_t width; + int32_t kerningindex; + uint32_t pixeldata; +}; + +struct hostfontchar { + uint8_t index; + int8_t baseline; + uint8_t height; + uint8_t width; + int32_t kerningindex; + uintptr_t pixeldata; +}; + +struct n64fontcharjpn { + uint16_t index; + int8_t baseline; + uint8_t height; + uint8_t width; + int16_t kerningindex; + uint32_t pixeldata; +}; + +struct hostfontcharjpn { + uint16_t index; + int8_t baseline; + uint8_t height; + uint8_t width; + int16_t kerningindex; + uintptr_t pixeldata; +}; + +static void extract_font(const char *filename, uint32_t romoffset, size_t srclen, int num_chars) +{ + size_t dstlen = srclen - (num_chars * sizeof(struct n64fontchar)) + (num_chars * sizeof(struct hostfontchar)) + 0x20; + uint8_t *src = &g_Rom[romoffset]; + uint8_t *dst = calloc(1, dstlen); + + // Kerning table + int32_t *src_kerning_table = (int32_t *) src; + int32_t *dst_kerning_table = (int32_t *) dst; + + for (int i = 0; i < 13 * 13; i++) { + dst_kerning_table[i] = srctodst32(src_kerning_table[i]); + } + + uint32_t src_offset = ALIGN(13 * 13 * 4, sizeof(uint32_t)); + uint32_t dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); + + // Character table + if (g_RomVersion == ROMVERSION_JPNFINAL) { + struct n64fontcharjpn *src_char_table = (struct n64fontcharjpn *) &src[src_offset]; + struct hostfontcharjpn *dst_char_table = (struct hostfontcharjpn *) &dst[dst_offset]; + uint32_t diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); + + for (int i = 0; i < num_chars; i++) { + dst_char_table[i].index = srctodst16(src_char_table[i].index); + dst_char_table[i].baseline = src_char_table[i].baseline; + dst_char_table[i].height = src_char_table[i].height; + dst_char_table[i].width = src_char_table[i].width; + dst_char_table[i].kerningindex = srctodst16(src_char_table[i].kerningindex); + dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? srctodst32(src_char_table[i].pixeldata) + diff : 0; + } + + src_offset += num_chars * sizeof(struct n64fontcharjpn); + dst_offset += num_chars * sizeof(struct hostfontcharjpn); + } else { + struct n64fontchar *src_char_table = (struct n64fontchar *) &src[src_offset]; + struct hostfontchar *dst_char_table = (struct hostfontchar *) &dst[dst_offset]; + uint32_t diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); + + for (int i = 0; i < num_chars; i++) { + dst_char_table[i].index = src_char_table[i].index; + dst_char_table[i].baseline = src_char_table[i].baseline; + dst_char_table[i].height = src_char_table[i].height; + dst_char_table[i].width = src_char_table[i].width; + dst_char_table[i].kerningindex = srctodst32(src_char_table[i].kerningindex); + dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? srctodst32(src_char_table[i].pixeldata) + diff : 0; + } + + src_offset += num_chars * sizeof(struct n64fontchar); + dst_offset += num_chars * sizeof(struct hostfontchar); + } + + // Pixel data + size_t len = srclen - src_offset; + + memcpy(&dst[dst_offset], &src[src_offset], len); + + dst_offset = ALIGN16(dst_offset + len); + + // Write it + char outfilename[1024]; + sprintf(outfilename, "%s/fonts/%s.bin", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(dst, dst_offset, 1, fp); + fclose(fp); + + free(dst); +} + +struct fontdef { + const char *name; + uint32_t offsets[3]; + int pal_extra_chars; +}; + +void extract_fonts(void) +{ + struct fontdef defs[] = { + // ntsc pal jpn + {"bankgothic", {0x7f2390, 0x7ddb90, 0x7e1a20}, 0}, + {"zurich", {0x7f4930, 0x7e0130, 0x7e3fc0}, 0}, + {"tahoma", {0x7f7860, 0x7e3060, 0x7e6ef0}, 0}, + {"numeric", {0x7f8b20, 0x7e4320, 0x7e81b0}, 0}, + {"handelgothicsm", {0x7f9d30, 0x7e5530, 0x7e93c0}, 1}, + {"handelgothicxs", {0x7fbfb0, 0x7e87b0, 0x7ec640}, 1}, + {"handelgothicmd", {0x7fdd80, 0x7eae20, 0x7eecb0}, 1}, + {"handelgothiclg", {0x8008e0, 0x7eee70, 0x7f2d00}, 0}, + {"ocramd", {0x803da0, 0x7f2330, 0x7f61c0}, 0}, + {"ocralg", {0x806ac0, 0x7f5050, 0x7f8ee0}, 0}, + {"end", {0x80a250, 0x7f87e0, 0x7fc670}, 0}, + }; + + int index = 0; + + switch (g_RomVersion) { + case ROMVERSION_NTSC10: + case ROMVERSION_NTSCFINAL: + index = 0; + break; + case ROMVERSION_PALFINAL: + index = 1; + break; + case ROMVERSION_JPNFINAL: + index = 2; + break; + } + + for (int i = 0; i < ARRAYCOUNT(defs) - 1; i++) { + int num_chars = g_RomVersion == ROMVERSION_PALFINAL && defs[i].pal_extra_chars ? 135 : 94; + size_t len = defs[i + 1].offsets[index] - defs[i].offsets[index]; + extract_font(defs[i].name, defs[i].offsets[index], len, num_chars); + } +} diff --git a/port/pdextract/ext_jpnfonts.c b/port/pdextract/ext_jpnfonts.c new file mode 100644 index 000000000..ea68b0d70 --- /dev/null +++ b/port/pdextract/ext_jpnfonts.c @@ -0,0 +1,32 @@ +#include +#include +#include +#include "common.h" + +static void extract_jpnfont(const char *filename, uint32_t romoffset, size_t len) +{ + char outfilename[1024]; + sprintf(outfilename, "%s/%s.bin", g_OutPath, filename); + + FILE *fp = openfile(outfilename); + fwrite(&g_Rom[romoffset], len, 1, fp); + fclose(fp); +} + +void extract_jpnfonts(void) +{ + switch (g_RomVersion) { + case ROMVERSION_NTSC10: + case ROMVERSION_NTSCFINAL: + extract_jpnfont("fontjpnsingle", 0x194440, 0xb020); + extract_jpnfont("fontjpnmulti", 0x19fb40, 0x1a80); + break; + case ROMVERSION_PALFINAL: + extract_jpnfont("fontjpnsingle", 0x17fc40, 0xb010); + extract_jpnfont("fontjpnmulti", 0x18b340, 0x1a80); + break; + case ROMVERSION_JPNFINAL: + extract_jpnfont("fontjpn", 0x178c40, 0x17920); + break; + } +} diff --git a/port/pdextract/ext_textures.c b/port/pdextract/ext_textures.c new file mode 100644 index 000000000..74e126163 --- /dev/null +++ b/port/pdextract/ext_textures.c @@ -0,0 +1,76 @@ +#include +#include +#include +#include "common.h" + +struct texture { + uint32_t soundsurfacetype : 4; + uint32_t surfacetype : 4; + uint32_t dataoffset : 24; + uint32_t unk04; +}; + +static void extract_textures_data(uint32_t romoffset, size_t len) +{ + char outfilename[1024]; + sprintf(outfilename, "%s/textures_data.bin", g_OutPath); + + FILE *fp = openfile(outfilename); + fwrite(&g_Rom[romoffset], len, 1, fp); + fclose(fp); +} + +static void extract_textures_table(uint32_t romoffset, size_t len) +{ + int num_textures = len / sizeof(struct texture); + uint8_t *dst = calloc(1, len); + + struct texture *n64texes = (struct texture *) &g_Rom[romoffset]; + struct texture *hosttexes = (struct texture *) dst; + + for (int i = 0; i < num_textures; i++) { + hosttexes[i].soundsurfacetype = n64texes[i].soundsurfacetype; + hosttexes[i].surfacetype = n64texes[i].surfacetype; + hosttexes[i].dataoffset = srctodst32(n64texes[i].dataoffset); + hosttexes[i].unk04 = 0; + } + + // Write it + char outfilename[1024]; + sprintf(outfilename, "%s/textures_table.bin", g_OutPath); + + FILE *fp = openfile(outfilename); + fwrite(dst, len, 1, fp); + fclose(fp); + + free(dst); +} + +void extract_textures(void) +{ + uint32_t data_offset = 0; + uint32_t table_offset = 0; + uint32_t end = 0; + + switch (g_RomVersion) { + case ROMVERSION_NTSC10: + case ROMVERSION_NTSCFINAL: + data_offset = 0x1d65f40; + table_offset = 0x1ff7ca0; + end = 0x1ffea20; + break; + case ROMVERSION_PALFINAL: + data_offset = 0x1d5ca20; + table_offset = 0x1fee780; + end = 0x1ff5500; + break; + case ROMVERSION_JPNFINAL: + data_offset = 0x1d61f90; + table_offset = 0x1ff68f0; + end = 0x1ffd6b0; + break; + } + + extract_textures_data(data_offset, table_offset - data_offset); + extract_textures_table(table_offset, end - table_offset); +} diff --git a/port/pdextract/gbi.c b/port/pdextract/gbi.c new file mode 100644 index 000000000..a59f77871 --- /dev/null +++ b/port/pdextract/gbi.c @@ -0,0 +1,189 @@ +#include +#include +#include +#include "common.h" + +#ifdef FORCE_BE32 +#define HOST_DWORDS_PER_CMD 1 +#elif UINTPTR_MAX == 0xFFFFFFFFFFFFFFFFu +#define HOST_DWORDS_PER_CMD 2 +#else +#define HOST_DWORDS_PER_CMD 1 +#endif + +struct vtx { + int16_t x; + int16_t y; + int16_t z; + uint8_t flags; + uint8_t colour; + int16_t s; + int16_t t; +}; + +uint32_t m_Segments[16]; +uint8_t m_Seen[1024]; +uint32_t m_SrcVtxOffset; +uint32_t m_DstVtxOffset; + +void gbi_reset(void) +{ + for (int i = 0; i < ARRAYCOUNT(m_Segments); i++) { + m_Segments[i] = 0; + } + + for (int i = 0; i < ARRAYCOUNT(m_Seen); i++) { + m_Seen[i] = 0; + } + + m_SrcVtxOffset = 0; + m_DstVtxOffset = 0; +} + +void gbi_set_segment(int segment, uint32_t offset) +{ + m_Segments[segment] = offset; +} + +void gbi_set_vtx(uint32_t src_offset, uint32_t dst_offset) +{ + m_SrcVtxOffset = src_offset; + m_DstVtxOffset = dst_offset; +} + +static void gbi_convert_col(uint8_t *dst, uint32_t dstpos, int count) +{ + for (int i = 0; i < count; i++) { + int index = dstpos / 4; + + if (!m_Seen[index]) { + uint32_t *col = (uint32_t *) &dst[dstpos]; + + *col = srctodst32(*col); + + m_Seen[index] = 1; + } + + dstpos += sizeof(uint32_t); + } +} + +static void gbi_convert_vtx(uint8_t *dst, uint32_t dstpos, int count) +{ + for (int i = 0; i < count; i++) { + int index = dstpos / 4; + + if (!m_Seen[index]) { + struct vtx *vtx = (struct vtx *) &dst[dstpos]; + + vtx->x = srctodst16(vtx->x); + vtx->y = srctodst16(vtx->y); + vtx->z = srctodst16(vtx->z); + vtx->s = srctodst16(vtx->s); + vtx->t = srctodst16(vtx->t); + + m_Seen[index] = 1; + } + + dstpos += 12; + } +} + +#define CMD_IS_VTX(cmd) ((cmd & 0xff00000000000000) == 0x0400000000000000) +#define CMD_IS_DL(cmd) ((cmd & 0xff00000000000000) == 0x0600000000000000) +#define CMD_IS_COL(cmd) ((cmd & 0xff00000000000000) == 0x0700000000000000) +#define CMD_IS_ENDDL(cmd) ((cmd & 0xff00000000000000) == 0xb800000000000000) +#define CMD_IS_MOVEWORD(cmd) ((cmd & 0xff00000000000000) == 0xbc00000000000000) + +#define CMD_HAS_ADDR(cmd) CMD_IS_VTX(cmd) \ + || CMD_IS_COL(cmd) \ + || CMD_IS_MOVEWORD(cmd) + +static void gbi_convert_vtx_by_cmd(uint64_t cmd, uint8_t *dst) +{ + uint8_t segment = cmd & 0xff000000; + uint8_t offset = cmd & 0x00ffffff; + uint32_t num_bytes = (cmd >> 32) & 0xffff; + int num_vertices = num_bytes / 12; + + if (segment == 5) { + uint32_t dst_offset = offset - m_SrcVtxOffset + m_DstVtxOffset; + gbi_convert_vtx(dst, dst_offset, num_vertices); + } else { + gbi_convert_vtx(dst, m_Segments[segment] + offset, num_vertices); + } +} + +static void gbi_convert_col_by_cmd(uint64_t cmd, uint8_t *dst) +{ + uint8_t segment = cmd & 0xff000000; + uint8_t offset = cmd & 0x00ffffff; + uint32_t num_bytes = (cmd >> 32) & 0xffff; + int num_colours = num_bytes / 4; + + if (segment == 5) { + uint32_t dst_offset = offset - m_SrcVtxOffset + m_DstVtxOffset; + gbi_convert_col(dst, dst_offset, num_colours); + } else { + gbi_convert_col(dst, m_Segments[segment] + offset, num_colours); + } +} + +/** + * Segment 5 is the start of the model file. The data in these files shifts + * depending on the pointer size, so this function adjusts the offset accordingly. + */ +static uint64_t gbi_rewrite_addr(uint64_t cmd) +{ + uint8_t segment = cmd & 0xff000000; + uint8_t offset = cmd & 0x00ffffff; + + if (segment == 5) { + if (offset < m_SrcVtxOffset) { + printf("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, m_SrcVtxOffset); + exit(EXIT_FAILURE); + } + + offset = offset - m_SrcVtxOffset + m_DstVtxOffset; + } + + return (cmd & 0xffffffffff000000) | offset; +} + +uint32_t gbi_convert_gdl(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos) +{ + dstpos = ALIGN8(dstpos); + + uint64_t *n64_cmd = (uint64_t *) &src[srcpos]; + uint64_t *host_cmd = (uint64_t *) &dst[dstpos]; + uint64_t cmd; + + do { + cmd = srctoh64(*n64_cmd); + +#if HOST_DWORDS_PER_CMD == 2 + if (CMD_HAS_ADDR(cmd)) { + cmd = gbi_rewrite_addr(cmd); + host_cmd[0] = htodst64(cmd & 0xffffffff00000000); + host_cmd[1] = htodst64(cmd & 0x00000000ffffffff); + } else { + host_cmd[0] = htodst64(cmd); + host_cmd[1] = 0; + } +#else + host_cmd[0] = htodst64(cmd); +#endif + dstpos += sizeof(*host_cmd) * HOST_DWORDS_PER_CMD; + + if (CMD_IS_VTX(cmd)) { + gbi_convert_vtx_by_cmd(cmd, dst); + } else if (CMD_IS_COL(cmd)) { + gbi_convert_col_by_cmd(cmd, dst); + } + + host_cmd += HOST_DWORDS_PER_CMD; + n64_cmd++; + } while (!CMD_IS_ENDDL(cmd)); + + return dstpos; +} diff --git a/port/pdextract/main.c b/port/pdextract/main.c new file mode 100644 index 000000000..c5230fe16 --- /dev/null +++ b/port/pdextract/main.c @@ -0,0 +1,173 @@ +#include +#include +#include +#include +#include "common.h" + +#define ROM_SIZE (1024 * 1024 * 32) + +uint8_t *g_Rom = NULL; +enum romversion g_RomVersion = 0; +char g_OutPath[1024] = {'\0'}; + +void extract_anims(void); +void extract_audio(void); +void extract_banners(void); +void extract_files(void); +void extract_fonts(void); +void extract_jpnfonts(void); +void extract_textures(void); + +/** + * We allow modded ROMs to be used, so we can't simply compare the ROM checksum. + */ +static enum romversion identify_rom_version(uint8_t *rom) +{ + char game_code[5]; + game_code[0] = rom[0x3b]; + game_code[1] = rom[0x3c]; + game_code[2] = rom[0x3d]; + game_code[3] = rom[0x3e]; + game_code[4] = '\0'; + + char version_byte = rom[0x3f]; + + if (strncmp((char *) &rom[0x20], "Perfect Dark DBGNTSC", 20) == 0) { + return ROMVERSION_NTSCBETA; + } + + if (strcmp(game_code, "NPDJ") == 0) { + return ROMVERSION_JPNFINAL; + } + + if (strcmp(game_code, "NPDE") == 0) { + if (version_byte == 1) { + return ROMVERSION_NTSCFINAL; + } + + if (version_byte == 0) { + return ROMVERSION_NTSC10; + } + } + + if (strcmp(game_code, "NPDP") == 0) { + if (rom[0x100f] == 0xe0) { + return ROMVERSION_PALBETA; + } + + if (rom[0x100f] == 0xf0) { + return ROMVERSION_PALFINAL; + } + } + + return ROMVERSION_UNKNOWN; +} + +static void flip_pairs(uint8_t *rom) +{ + uint16_t *ptr = (uint16_t *) rom; + + for (int i = 0; i < ROM_SIZE / 2; i++) { + ptr[i] = __bswap_16(ptr[i]); + } +} + +static void flip_words(uint8_t *rom) +{ + uint32_t *ptr = (uint32_t *) rom; + + for (int i = 0; i < ROM_SIZE / 4; i++) { + ptr[i] = __bswap_32(ptr[i]); + } +} + +static void extract_rom(char *romfile) +{ + FILE *fp = fopen(romfile, "rb"); + + if (fp == NULL) { + fprintf(stderr, "Unable to open '%s' for reading.\n", romfile); + exit(EXIT_FAILURE); + } + + fseek(fp, 0, SEEK_END); + + if (ftell(fp) != ROM_SIZE) { + fprintf(stderr, "The ROM size is not 32MB. Is this a Perfect Dark ROM?\n"); + exit(EXIT_FAILURE); + } + + fseek(fp, 0, SEEK_SET); + + g_Rom = malloc(ROM_SIZE); + fread(g_Rom, 1, ROM_SIZE, fp); + fclose(fp); + + uint32_t magic = (g_Rom[0] << 24) | (g_Rom[1] << 16) | (g_Rom[2] << 8) | g_Rom[3]; + + switch (magic) { + case 0x80371240: + break; + case 0x37804012: + flip_pairs(g_Rom); + break; + case 0x40123780: + flip_words(g_Rom); + break; + default: + fprintf(stderr, "Unable to detect ROM header. Is this an N64 ROM?\n"); + exit(EXIT_FAILURE); + break; + } + + g_RomVersion = identify_rom_version(g_Rom); + + if (g_RomVersion == ROMVERSION_NTSCBETA || g_RomVersion == ROMVERSION_PALBETA) { + fprintf(stderr, "The beta versions are not supported.\n"); + exit(EXIT_FAILURE); + } + + if (g_RomVersion == ROMVERSION_UNKNOWN) { + fprintf(stderr, "Unable to determine your Perfect Dark version. Is this a Perfect Dark ROM?\n"); + exit(EXIT_FAILURE); + } + + extract_anims(); + extract_audio(); + extract_files(); + extract_fonts(); + extract_jpnfonts(); + extract_textures(); + extract_banners(); + + free(g_Rom); + g_Rom = NULL; +} + +int main(int argc, char **argv) +{ + char *romfile = NULL; + + if (argc < 2) { + fprintf(stderr, "Usage: pd-extract [PATH]\n"); + fprintf(stderr, "Read ROMFILE, writing assets to PATH.\n"); + fprintf(stderr, "With no PATH, assume \"extracted/\".\n"); + return EXIT_FAILURE; + } + + romfile = argv[1]; + + if (argc > 2) { + strcpy(g_OutPath, argv[2]); + } else { + strcpy(g_OutPath, "extracted"); + } + + if (g_OutPath[strlen(g_OutPath) - 1] == '/') { + g_OutPath[strlen(g_OutPath) - 1] = '\0'; + } + + extract_rom(romfile); + + return EXIT_SUCCESS; +} diff --git a/port/pdextract/util.c b/port/pdextract/util.c new file mode 100644 index 000000000..8cdcb58f3 --- /dev/null +++ b/port/pdextract/util.c @@ -0,0 +1,103 @@ +#include +#include +#include +#include +#include +#include +#include + +FILE *openfile(char *filename) +{ + char path[1024]; + struct stat status; + + memcpy(path, filename, strlen(filename)); + dirname(path); + + while (stat(path, &status) == -1) { +// while (mkdir(path, 0755) == -1) { + while (mkdir(path) == -1) { + dirname(path); + } + + memcpy(path, filename, strlen(filename)); + dirname(path); + } + + FILE *fp = fopen(filename, "wb"); + + if (fp == NULL) { + fprintf(stderr, "Unable to open '%s' for writing\n", filename); + exit(EXIT_FAILURE); + } + + return fp; +} + +size_t rzip_get_infsize(uint8_t *src) +{ + if (src[0] != 0x11 || src[1] != 0x73) { + fprintf(stderr, "rzip_get_infsize: 1173 not found\n"); + exit(EXIT_FAILURE); + } + + return src[2] << 16 | (src[3] << 8) | src[4]; +} + +int rzip_inflate(uint8_t *dst, size_t dstlen, uint8_t *src, size_t srclen) +{ + if (src[0] != 0x11 || src[1] != 0x73) { + fprintf(stderr, "rzip_inflate: 1173 not found\n"); + + for (int i = 0; i < 16; i++) { + fprintf(stderr, "%02x ", src[i]); + } + + fprintf(stderr, "\n"); + + exit(EXIT_FAILURE); + } + + z_stream stream; + stream.zalloc = Z_NULL; + stream.zfree = Z_NULL; + stream.opaque = Z_NULL; + stream.avail_in = srclen - 5; + stream.next_in = &src[5]; + stream.avail_out = dstlen; + stream.next_out = dst; + + inflateInit2(&stream, -15); + int ret = inflate(&stream, Z_FINISH); + inflateEnd(&stream); + + return ret; +} + +int rzip_deflate(uint8_t *dst, size_t *dstlen, uint8_t *src, size_t srclen) +{ + dst[0] = 0x11; + dst[1] = 0x73; + dst[2] = (srclen >> 16) & 0xff; + dst[3] = (srclen >> 8) & 0xff; + dst[4] = srclen & 0xff; + + *dstlen = *dstlen - 5; + + z_stream stream; + stream.zalloc = Z_NULL; + stream.zfree = Z_NULL; + stream.opaque = Z_NULL; + stream.avail_in = srclen; + stream.next_in = src; + stream.avail_out = *dstlen; + stream.next_out = &dst[5]; + + deflateInit2(&stream, 9, Z_DEFLATED, -15, 9, Z_DEFAULT_STRATEGY); + int ret = deflate(&stream, Z_FINISH); + deflateEnd(&stream); + + *dstlen = stream.next_out - dst; + + return ret; +} From 4dbbcbeb5838b4fa722144f4c64f9f968addfb2a Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sat, 6 Jul 2024 01:16:39 +0800 Subject: [PATCH 03/81] portx64: changed pointers stored in u32 to uintptr_t - adjusted hardcoded mask/hardcoded offsets used in memory operations (modelasm_c.c) - makefile: enabled x64 support and added lib dependency - title: increase alloc size - tex: adjustment to calculations involving GDL sizes --- Makefile.port | 8 ++---- include/PR/gbi.h | 58 +++++++++++++++++++++++----------------- port/src/pdmain.c | 2 +- src/game/bondgun.c | 26 +++++++++--------- src/game/setup.c | 30 ++++++++++----------- src/game/tex.c | 9 +++++++ src/game/texdecompress.c | 2 +- src/game/texreset.c | 2 +- src/game/texselect.c | 2 +- src/game/title.c | 8 +++--- src/game/vtxstore.c | 4 +-- src/include/bss.h | 2 +- src/include/game/title.h | 2 +- src/include/lib/model.h | 2 +- src/include/lib/rdp.h | 2 +- src/include/types.h | 8 +++--- src/lib/dma.c | 4 +-- src/lib/main.c | 6 ++--- src/lib/mema.c | 2 +- src/lib/model.c | 6 ++--- src/lib/modelasm_c.c | 13 +++++++++ src/lib/rdp.c | 2 +- src/lib/vi.c | 4 +++ 23 files changed, 117 insertions(+), 87 deletions(-) diff --git a/Makefile.port b/Makefile.port index 650f02474..4c451c939 100644 --- a/Makefile.port +++ b/Makefile.port @@ -86,12 +86,8 @@ endif # Set whether the target arch is 64- or 32-bit. ifneq (,$(findstring 64,$(TARGET_PLATFORM))$(findstring armv8,$(TARGET_PLATFORM))) - # TODO: we're not 64-bit compatible yet, error out if building the actual game - ifeq (,$(findstring clean,$(MAKECMDGOALS))) - $(error 64-bit target platforms are not supported yet) - endif TARGET_64BIT = 1 -else # TODO +else TARGET_64BIT = 0 endif @@ -151,7 +147,7 @@ G_DIR := src/generated/$(ROMID) ifneq (,$(findstring windows,$(TARGET_PLATFORM))) TARGET_CFLAGS := $(shell pkg-config sdl2 --cflags-only-I) - TARGET_LDFLAGS := $(shell pkg-config sdl2 --libs) -lz -lopengl32 -ldbghelp + TARGET_LDFLAGS := $(shell pkg-config sdl2 --libs) -lz -lopengl32 -ldbghelp -lws2_32 # on windows/mingw we need this to be built with a 32-bit compiler so it finds the correct libs TOOLCHAIN ?= i686-w64-mingw32- # on GCC link libstdc++ statically diff --git a/include/PR/gbi.h b/include/PR/gbi.h index e36f15ec2..27993ea61 100644 --- a/include/PR/gbi.h +++ b/include/PR/gbi.h @@ -1596,7 +1596,11 @@ typedef struct { */ typedef union { Gwords words; +#ifdef PLATFORM_64BIT + u8 bytes[16]; +#else u8 bytes[8]; +#endif Gdma dma; Gvtx vtx; Gtri tri; @@ -1619,7 +1623,11 @@ typedef union { Gloadtlut loadtlut; #endif GunkC0 unkc0; +#ifdef PLATFORM_64BIT + __int128 force_structure_alignment; +#else long long int force_structure_alignment; +#endif } Gfx; #ifdef PLATFORM_BIG_ENDIAN @@ -1642,12 +1650,12 @@ typedef union { Gfx *_g = (Gfx *)(pkt); \ \ _g->words.w0 = _SHIFTL((c), 24, 8) | _SHIFTL((l), 0, 24); \ - _g->words.w1 = (unsigned int)(s); \ + _g->words.w1 = (uintptr_t)(s); \ } #define gsDma0p(c, s, l) \ { \ - _SHIFTL((c), 24, 8) | _SHIFTL((l), 0, 24), (unsigned int)(s) \ + _SHIFTL((c), 24, 8) | _SHIFTL((l), 0, 24), (uintptr_t)(s) \ } #define gDma1p(pkt, c, s, l, p) \ @@ -1656,14 +1664,14 @@ typedef union { \ _g->words.w0 = (_SHIFTL((c), 24, 8) | _SHIFTL((p), 16, 8) | \ _SHIFTL((l), 0, 16)); \ - _g->words.w1 = (unsigned int)(s); \ + _g->words.w1 = (uintptr_t)(s); \ } #define gsDma1p(c, s, l, p) \ { \ (_SHIFTL((c), 24, 8) | _SHIFTL((p), 16, 8) | \ _SHIFTL((l), 0, 16)), \ - (uintptr_t)(s) \ + (uintptr_t)(s) \ } #define gDma2p(pkt, c, adrs, len, idx, ofs) \ @@ -1671,14 +1679,14 @@ typedef union { Gfx *_g = (Gfx *)(pkt); \ _g->words.w0 = (_SHIFTL((c),24,8)|_SHIFTL(((len)-1)/8,19,5)| \ _SHIFTL((ofs)/8,8,8)|_SHIFTL((idx),0,8)); \ - _g->words.w1 = (unsigned int)(adrs); \ + _g->words.w1 = (uintptr_t)(adrs); \ } #define gsDma2p(c, adrs, len, idx, ofs) \ { \ (_SHIFTL((c),24,8)|_SHIFTL(((len)-1)/8,19,5)| \ _SHIFTL((ofs)/8,8,8)|_SHIFTL((idx),0,8)), \ - (unsigned int)(adrs) \ + (uintptr_t)(adrs) \ } #define gSPNoOp(pkt) gDma0p(pkt, G_SPNOOP, 0, 0) @@ -1727,12 +1735,12 @@ typedef union { Gfx *_g = (Gfx *)(pkt); \ \ _g->words.w0 = _SHIFTL((c), 24, 8); \ - _g->words.w1 = (unsigned int)(p0); \ + _g->words.w1 = (uintptr_t)(p0); \ } #define gsImmp1(c, p0) \ { \ - _SHIFTL((c), 24, 8), (unsigned int)(p0) \ + _SHIFTL((c), 24, 8), (uintptr_t)(p0) \ } #define gImmp2(pkt, c, p0, p1) \ @@ -1769,13 +1777,13 @@ typedef union { \ _g->words.w0 = (_SHIFTL((c), 24, 8) | _SHIFTL((p0), 8, 16) | \ _SHIFTL((p1), 0, 8)); \ - _g->words.w1 = (unsigned int) (dat); \ + _g->words.w1 = (uintptr_t) (dat); \ } #define gsImmp21(c, p0, p1, dat) \ { \ _SHIFTL((c), 24, 8) | _SHIFTL((p0), 8, 16) | _SHIFTL((p1), 0, 8), \ - (unsigned int) (dat) \ + (uintptr_t) (dat) \ } #define gMoveWd(pkt, index, offset, data) \ @@ -1918,7 +1926,7 @@ typedef union { \ _g->words.w0 = _SHIFTL(G_CULLDL, 24, 8) | \ ((0x0f & (vstart))*40); \ - _g->words.w1 = (unsigned int)((0x0f & ((vend)+1))*40); \ + _g->words.w1 = (uintptr_t)((0x0f & ((vend)+1))*40); \ } // Removed in PD @@ -2239,12 +2247,12 @@ typedef union { Gfx *_g = (Gfx *)(pkt); \ \ _g->words.w0 = _SHIFTL(G_SETGEOMETRYMODE, 24, 8); \ - _g->words.w1 = (unsigned int)(word); \ + _g->words.w1 = (uintptr_t)(word); \ } #define gsSPSetGeometryMode(word) \ { \ - _SHIFTL(G_SETGEOMETRYMODE, 24, 8), (unsigned int)(word) \ + _SHIFTL(G_SETGEOMETRYMODE, 24, 8), (uintptr_t)(word) \ } #define gSPClearGeometryMode(pkt, word) \ @@ -2252,12 +2260,12 @@ typedef union { Gfx *_g = (Gfx *)(pkt); \ \ _g->words.w0 = _SHIFTL(G_CLEARGEOMETRYMODE, 24, 8); \ - _g->words.w1 = (unsigned int)(word); \ + _g->words.w1 = (uintptr_t)(word); \ } #define gsSPClearGeometryMode(word) \ { \ - _SHIFTL(G_CLEARGEOMETRYMODE, 24, 8), (unsigned int)(word) \ + _SHIFTL(G_CLEARGEOMETRYMODE, 24, 8), (uintptr_t)(word) \ } #define gSPSetOtherMode(pkt, cmd, sft, len, data) \ @@ -2266,13 +2274,13 @@ typedef union { \ _g->words.w0 = (_SHIFTL(cmd, 24, 8) | _SHIFTL(sft, 8, 8) | \ _SHIFTL(len, 0, 8)); \ - _g->words.w1 = (unsigned int)(data); \ + _g->words.w1 = (uintptr_t)(data); \ } #define gsSPSetOtherMode(cmd, sft, len, data) \ { \ _SHIFTL(cmd, 24, 8) | _SHIFTL(sft, 8, 8) | _SHIFTL(len, 0, 8), \ - (unsigned int)(data) \ + (uintptr_t)(data) \ } /* @@ -2323,14 +2331,14 @@ typedef union { \ _g->words.w0 = _SHIFTL(cmd, 24, 8) | _SHIFTL(fmt, 21, 3) | \ _SHIFTL(siz, 19, 2) | _SHIFTL((width)-1, 0, 12); \ - _g->words.w1 = (unsigned int)(i); \ + _g->words.w1 = (uintptr_t)(i); \ } #define gsSetImage(cmd, fmt, siz, width, i) \ { \ _SHIFTL(cmd, 24, 8) | _SHIFTL(fmt, 21, 3) | \ _SHIFTL(siz, 19, 2) | _SHIFTL((width)-1, 0, 12), \ - (unsigned int)(i) \ + (uintptr_t)(i) \ } #define gDPSetColorImage(pkt, f, s, w, i) gSetImage(pkt, G_SETCIMG, f, s, w, i) @@ -2356,13 +2364,13 @@ typedef union { Gfx *_g = (Gfx *)(pkt); \ \ _g->words.w0 = _SHIFTL(G_SETCOMBINE, 24, 8) | _SHIFTL(muxs0, 0, 24); \ - _g->words.w1 = (unsigned int)(muxs1); \ + _g->words.w1 = (uintptr_t)(muxs1); \ } #define gsDPSetCombine(muxs0, muxs1) \ { \ _SHIFTL(G_SETCOMBINE, 24, 8) | _SHIFTL(muxs0, 0, 24), \ - (unsigned int)(muxs1) \ + (uintptr_t)(muxs1) \ } #define GCCc0w0(saRGB0, mRGB0, saA0, mA0) \ @@ -2435,12 +2443,12 @@ typedef union { Gfx *_g = (Gfx *)(pkt); \ \ _g->words.w0 = _SHIFTL(c, 24, 8); \ - _g->words.w1 = (unsigned int)(d); \ + _g->words.w1 = (uintptr_t)(d); \ } #define gsDPSetColor(c, d) \ { \ - _SHIFTL(c, 24, 8), (unsigned int)(d) \ + _SHIFTL(c, 24, 8), (uintptr_t)(d) \ } #define DPRGBColor(pkt, cmd, r, g, b, a) \ @@ -2521,13 +2529,13 @@ typedef union { Gfx *_g = (Gfx *)(pkt); \ \ _g->words.w0 = _SHIFTL(G_RDPSETOTHERMODE,24,8)|_SHIFTL(mode0,0,24); \ - _g->words.w1 = (unsigned int)(mode1); \ + _g->words.w1 = (uintptr_t)(mode1); \ } #define gsDPSetOtherMode(mode0, mode1) \ { \ _SHIFTL(G_RDPSETOTHERMODE,24,8)|_SHIFTL(mode0,0,24), \ - (unsigned int)(mode1) \ + (uintptr_t)(mode1) \ } /* diff --git a/port/src/pdmain.c b/port/src/pdmain.c index 2cd9baffb..959574d4c 100644 --- a/port/src/pdmain.c +++ b/port/src/pdmain.c @@ -570,7 +570,7 @@ void mainTick(void) viUpdateMode(); } - rdpCreateTask(gdlstart, gdl, 0, (s32) &msg); + rdpCreateTask(gdlstart, gdl, 0, (uintptr_t) &msg); memaPrint(); profileSetMarker(PROFILE_MAINTICK_END); } diff --git a/src/game/bondgun.c b/src/game/bondgun.c index 8c99e39c1..e6fc19619 100644 --- a/src/game/bondgun.c +++ b/src/game/bondgun.c @@ -6489,9 +6489,9 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * rwdata->distance.visible = false; node->child = rodata->distance.target; ptr[0] = 0; - ptr[1] = (s32)rwdata; - ptr[2] = (s32)node; - ptr[3] = (s32)rodata->distance.target; + ptr[1] = (uintptr_t)rwdata; + ptr[2] = (uintptr_t)node; + ptr[3] = (uintptr_t)rodata->distance.target; ptr += 4; len += 16; break; @@ -6501,9 +6501,9 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * rwdata->toggle.visible = true; node->child = rodata->toggle.target; ptr[0] = 1; - ptr[1] = (s32)rwdata; - ptr[2] = (s32)node; - ptr[3] = (s32)rodata->toggle.target; + ptr[1] = (uintptr_t)rwdata; + ptr[2] = (uintptr_t)node; + ptr[3] = (uintptr_t)rodata->toggle.target; ptr += 4; len += 16; break; @@ -6512,7 +6512,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * rwdata->headspot.headmodeldef = NULL; rwdata->headspot.rwdatas = NULL; ptr[0] = 2; - ptr[1] = (s32)rwdata; + ptr[1] = (uintptr_t)rwdata; ptr += 2; len += 8; break; @@ -6520,7 +6520,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * rwdata = modelGetNodeRwData(model, node); rwdata->type0b.unk00 = 0; ptr[0] = 3; - ptr[1] = (s32)rwdata; + ptr[1] = (uintptr_t)rwdata; ptr += 2; len += 8; break; @@ -6528,7 +6528,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * rwdata = modelGetNodeRwData(model, node); rwdata->chrgunfire.visible = false; ptr[0] = 4; - ptr[1] = (s32)rwdata; + ptr[1] = (uintptr_t)rwdata; ptr += 2; len += 8; break; @@ -6539,10 +6539,10 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * rwdata->dl.gdl = rodata->dl.opagdl; rwdata->dl.colours = (void *)ALIGN8((uintptr_t)&rodata->dl.vertices[rodata->dl.numvertices]); ptr[0] = 5; - ptr[1] = (s32)rwdata; - ptr[2] = (s32)rwdata->dl.vertices; - ptr[3] = (s32)rwdata->dl.gdl; - ptr[4] = (s32)rwdata->dl.colours; + ptr[1] = (uintptr_t)rwdata; + ptr[2] = (uintptr_t)rwdata->dl.vertices; + ptr[3] = (uintptr_t)rwdata->dl.gdl; + ptr[4] = (uintptr_t)rwdata->dl.colours; ptr += 5; len += 20; break; diff --git a/src/game/setup.c b/src/game/setup.c index 912284624..ec9337667 100644 --- a/src/game/setup.c +++ b/src/game/setup.c @@ -1844,7 +1844,7 @@ void setupCreateProps(s32 stagenum) truck->speedtime60 = -1; truck->turnrot60 = 0; truck->roty = 0; - truck->ailist = ailistFindById((u32)truck->ailist); + truck->ailist = ailistFindById((uintptr_t)truck->ailist); truck->aioffset = 0; truck->aireturnlist = -1; truck->path = NULL; @@ -1866,7 +1866,7 @@ void setupCreateProps(s32 stagenum) car->roty = 0; car->rotx = 0; car->speedtime60 = -1; - car->ailist = ailistFindById((s32)car->ailist); + car->ailist = ailistFindById((uintptr_t)car->ailist); car->aioffset = 0; car->aireturnlist = -1; car->path = NULL; @@ -1895,7 +1895,7 @@ void setupCreateProps(s32 stagenum) chopper->gunrotx = 0; chopper->barrelrot = 0; chopper->barrelrotspeed = 0; - chopper->ailist = ailistFindById((u32)chopper->ailist); + chopper->ailist = ailistFindById((uintptr_t)chopper->ailist); chopper->aioffset = 0; chopper->aireturnlist = -1; chopper->path = NULL; @@ -1942,7 +1942,7 @@ void setupCreateProps(s32 stagenum) heli->yrot = 0; heli->speedtime60 = -1; heli->rotoryspeedtime = -1; - heli->ailist = ailistFindById((u32)heli->ailist); + heli->ailist = ailistFindById((uintptr_t)heli->ailist); heli->aioffset = 0; heli->aireturnlist = -1; heli->path = NULL; @@ -2131,8 +2131,8 @@ void setupCreateProps(s32 stagenum) case OBJTYPE_LINKLIFTDOOR: { struct linkliftdoorobj *link = (struct linkliftdoorobj *)obj; - s32 dooroffset = (s32)link->door; - s32 liftoffset = (s32)link->lift; + uintptr_t dooroffset = (uintptr_t)link->door; + uintptr_t liftoffset = (uintptr_t)link->lift; struct defaultobj *door = setupGetObjByCmdIndex(index + dooroffset); struct defaultobj *lift = setupGetObjByCmdIndex(index + liftoffset); @@ -2149,9 +2149,9 @@ void setupCreateProps(s32 stagenum) case OBJTYPE_SAFEITEM: { struct safeitemobj *link = (struct safeitemobj *)obj; - s32 itemoffset = (s32)link->item; - s32 safeoffset = (s32)link->safe; - s32 dooroffset = (s32)link->door; + uintptr_t itemoffset = (uintptr_t)link->item; + uintptr_t safeoffset = (uintptr_t)link->safe; + uintptr_t dooroffset = (uintptr_t)link->door; struct defaultobj *item = setupGetObjByCmdIndex(index + itemoffset); struct defaultobj *safe = setupGetObjByCmdIndex(index + safeoffset); struct defaultobj *door = setupGetObjByCmdIndex(index + dooroffset); @@ -2173,8 +2173,8 @@ void setupCreateProps(s32 stagenum) case OBJTYPE_PADLOCKEDDOOR: { struct padlockeddoorobj *link = (struct padlockeddoorobj *)obj; - s32 dooroffset = (s32)link->door; - s32 lockoffset = (s32)link->lock; + uintptr_t dooroffset = (uintptr_t)link->door; + uintptr_t lockoffset = (uintptr_t)link->lock; struct defaultobj *door = setupGetObjByCmdIndex(index + dooroffset); struct defaultobj *lock = setupGetObjByCmdIndex(index + lockoffset); @@ -2192,9 +2192,9 @@ void setupCreateProps(s32 stagenum) case OBJTYPE_CONDITIONALSCENERY: { struct linksceneryobj *link = (struct linksceneryobj *)obj; - s32 triggeroffset = (s32)link->trigger; - s32 unexpoffset = (s32)link->unexp; - s32 expoffset = (s32)link->exp; + uintptr_t triggeroffset = (uintptr_t)link->trigger; + uintptr_t unexpoffset = (uintptr_t)link->unexp; + uintptr_t expoffset = (uintptr_t)link->exp; struct defaultobj *trigger = setupGetObjByCmdIndex(index + triggeroffset); struct defaultobj *unexp = NULL; struct defaultobj *exp = NULL; @@ -2244,7 +2244,7 @@ void setupCreateProps(s32 stagenum) case OBJTYPE_BLOCKEDPATH: { struct blockedpathobj *blockedpath = (struct blockedpathobj *)obj; - s32 objoffset = (s32)blockedpath->blocker; + uintptr_t objoffset = (uintptr_t)blockedpath->blocker; struct defaultobj *blocker = setupGetObjByCmdIndex(index + objoffset); if (blocker && blocker->prop) { diff --git a/src/game/tex.c b/src/game/tex.c index 953b5a464..f63a00c23 100644 --- a/src/game/tex.c +++ b/src/game/tex.c @@ -861,7 +861,11 @@ s32 texLoadFromGdl(Gfx *instart, s32 gdlsizeinbytes, Gfx *outstart, struct texpo ingdl = instart; outgdl = outstart; +#ifdef PLATFORM_64BIT + numcmdsremaining = gdlsizeinbytes >> 4; +#else numcmdsremaining = gdlsizeinbytes >> 3; +#endif texResetTiles(); @@ -1157,7 +1161,12 @@ s32 texLoadFromGdl(Gfx *instart, s32 gdlsizeinbytes, Gfx *outstart, struct texpo void texCopyGdls(Gfx *src, Gfx *dst, s32 count) { +#ifdef PLATFORM_64BIT + count = (count >> 4); +#else count = (count >> 3); +#endif + src = src + (count - 1); dst = dst + (count - 1); diff --git a/src/game/texdecompress.c b/src/game/texdecompress.c index a6a4ce296..71d7b961d 100644 --- a/src/game/texdecompress.c +++ b/src/game/texdecompress.c @@ -2269,7 +2269,7 @@ void texLoad(texnum_t *updateword, struct texpool *pool, bool unusedarg) // Copy the compressed texture to RAM dmaExec(alignedcompbuffer, (romptr_t) REF_SEG _texturesdataSegmentRomStart + (thisoffset & 0xfffffff8), - ((u32) (nextoffset - thisoffset) + 0x1f) >> 4 << 4); + ((uintptr_t) (nextoffset - thisoffset) + 0x1f) >> 4 << 4); compptr = (u8 *) alignedcompbuffer + (thisoffset & 7); } thisoffset = 0; diff --git a/src/game/texreset.c b/src/game/texreset.c index 1daf8c737..85297c81a 100644 --- a/src/game/texreset.c +++ b/src/game/texreset.c @@ -144,7 +144,7 @@ void texReset(void) g_BlurFbDirty = true; #endif - g_TexWords = mempAlloc(ALIGN16(g_TexNumConfigs * 4), MEMPOOL_STAGE); + g_TexWords = mempAlloc(ALIGN16(g_TexNumConfigs * sizeof(uintptr_t)), MEMPOOL_STAGE); for (i = 0; i < g_TexNumConfigs; i++) { g_TexWords[i] = NULL; diff --git a/src/game/texselect.c b/src/game/texselect.c index ee0ad8acd..c2abcf58b 100644 --- a/src/game/texselect.c +++ b/src/game/texselect.c @@ -302,7 +302,7 @@ void texSelect(Gfx **gdlptr, struct textureconfig *tconfig, u32 arg2, s32 arg3, #ifdef __sgi index = tconfig - g_TexWallhitConfigs; #else - index = ((s32) tconfig - (s32) g_TexWallhitConfigs) / sizeof(struct textureconfig); + index = ((uintptr_t) tconfig - (uintptr_t) g_TexWallhitConfigs) / sizeof(struct textureconfig); #endif if (index >= 0 && index < g_TexNumConfigs) { diff --git a/src/game/title.c b/src/game/title.c index db1a78531..c37103a2e 100644 --- a/src/game/title.c +++ b/src/game/title.c @@ -838,8 +838,8 @@ Gfx *titleRenderPdLogoModel(Gfx *gdl, struct model *model, bool arg2, f32 arg3, rwdata = modelGetNodeRwData(model, node2); } - s1 = (Col *)ALIGN8(s5rodata->numvertices * sizeof(Vtx) + (s32)s5rodata->vertices); - s2 = (Col *)ALIGN8(s1rodata->numvertices * (s32) sizeof(Vtx) + (s32)s1rodata->vertices); + s1 = (Col *)ALIGN8(s5rodata->numvertices * sizeof(Vtx) + (uintptr_t)s5rodata->vertices); + s2 = (Col *)ALIGN8(s1rodata->numvertices * sizeof(Vtx) + (uintptr_t)s1rodata->vertices); a3 = s5rodata->vertices; t0 = s1rodata->vertices; @@ -882,8 +882,8 @@ Gfx *titleRenderPdLogoModel(Gfx *gdl, struct model *model, bool arg2, f32 arg3, spfc[j].a = alpha2; } - sp100 = (void *)ALIGN8(s5rodata->numvertices * sizeof(Vtx) + (s32)sp100); - spfc = (void *)ALIGN8(s5rodata->numcolours * sizeof(u32) + (s32)spfc); + sp100 = (void *)ALIGN8(s5rodata->numvertices * sizeof(Vtx) + (uintptr_t)sp100); + spfc = (void *)ALIGN8(s5rodata->numcolours * sizeof(u32) + (uintptr_t)spfc); } } diff --git a/src/game/vtxstore.c b/src/game/vtxstore.c index de494845e..4999ea6de 100644 --- a/src/game/vtxstore.c +++ b/src/game/vtxstore.c @@ -64,8 +64,8 @@ void vtxstoreFixRefs(void *find, void *replacement) case MODELNODETYPE_DL: rodata = &node->rodata->dl; - if (model->rwdatas[rodata->rwdataindex] == (u32) find) { - model->rwdatas[rodata->rwdataindex] = (u32) replacement; + if (model->rwdatas[rodata->rwdataindex] == (uintptr_t) find) { + model->rwdatas[rodata->rwdataindex] = (uintptr_t) replacement; } break; case MODELNODETYPE_DISTANCE: diff --git a/src/include/bss.h b/src/include/bss.h index e07a9d931..e59e90b29 100644 --- a/src/include/bss.h +++ b/src/include/bss.h @@ -250,7 +250,7 @@ extern struct seqchannel g_SeqChannels[3]; extern u32 g_AudioXReasonsActive[4]; extern s32 g_MusicXReasonMinDurations[4]; extern s32 g_MusicXReasonMaxDurations[4]; -extern u32 *g_LangBanks[69]; +extern uintptr_t *g_LangBanks[69]; extern struct jpncharpixels *g_JpnCharCachePixels; extern struct jpncacheitem *g_JpnCacheCacheItems; extern struct texture *g_Textures; diff --git a/src/include/game/title.h b/src/include/game/title.h index 6dc4ed517..02ecfb690 100644 --- a/src/include/game/title.h +++ b/src/include/game/title.h @@ -4,7 +4,7 @@ #include "data.h" #include "types.h" -#define TITLE_ALLOCSIZE 1024 * 286 +#define TITLE_ALLOCSIZE 1024 * 332 extern u32 var800624d4; extern u32 var800624d8; diff --git a/src/include/lib/model.h b/src/include/lib/model.h index 8d6cef0c8..1e75e6b3b 100644 --- a/src/include/lib/model.h +++ b/src/include/lib/model.h @@ -97,7 +97,7 @@ void modelRenderNodeChrGunfire(struct modelrenderdata *renderdata, struct model void modelRender(struct modelrenderdata *renderdata, struct model *model); bool modelTestBboxNodeForHit(struct modelrodata_bbox *bbox, Mtxf *mtx, struct coord *arg2, struct coord *arg3); s32 modelTestForHit(struct model *model, struct coord *arg1, struct coord *arg2, struct modelnode **startnode); -void modelPromoteNodeOffsetsToPointers(struct modelnode *node, u32 vma, u32 fileramaddr); +void modelPromoteNodeOffsetsToPointers(struct modelnode *node, u32 vma, uintptr_t fileramaddr); void modelPromoteOffsetsToPointers(struct modeldef *modeldef, u32 arg1, uintptr_t arg2); s32 modelCalculateRwDataIndexes(struct modelnode *node); void modelAllocateRwData(struct modeldef *modeldef); diff --git a/src/include/lib/rdp.h b/src/include/lib/rdp.h index 6d54e5e44..ee489b81b 100644 --- a/src/include/lib/rdp.h +++ b/src/include/lib/rdp.h @@ -5,6 +5,6 @@ #include "types.h" void rdpInit(void); -void rdpCreateTask(Gfx *gdlstart, Gfx *gdlend, u32 arg2, s32 msg); +void rdpCreateTask(Gfx *gdlstart, Gfx *gdlend, u32 arg2, uintptr_t msg); #endif diff --git a/src/include/types.h b/src/include/types.h index ae575c805..88812911c 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -2856,9 +2856,9 @@ struct cover { struct padsfileheader { s32 numpads; s32 numcovers; - s32 waypointsoffset; - s32 waygroupsoffset; - s32 coversoffset; + uintptr_t waypointsoffset; + uintptr_t waygroupsoffset; + uintptr_t coversoffset; u16 padoffsets[1]; }; @@ -5168,7 +5168,7 @@ struct shieldhit { }; struct bgroom { - u32 unk00; + uintptr_t unk00; struct coord pos; u8 br_light_min; u8 br_light_max; diff --git a/src/lib/dma.c b/src/lib/dma.c index e3701a677..698802c0b 100644 --- a/src/lib/dma.c +++ b/src/lib/dma.c @@ -181,8 +181,8 @@ void dmaExecHighPriority(void *memaddr, romptr_t romaddr, u32 len) */ void *dmaExecWithAutoAlign(void *memaddr, romptr_t romaddr, u32 len) { - u32 alignedrom = ALIGN2(romaddr); - u32 alignedmem = ALIGN16((uintptr_t) memaddr); + uintptr_t alignedrom = ALIGN2(romaddr); + uintptr_t alignedmem = ALIGN16((uintptr_t) memaddr); u32 offset = romaddr - alignedrom; // 0 or 1 u32 alignedlen = ALIGN16(offset + len); diff --git a/src/lib/main.c b/src/lib/main.c index 12ea8095c..c03da5235 100644 --- a/src/lib/main.c +++ b/src/lib/main.c @@ -489,7 +489,7 @@ void mainInit(void) if (*(s16 *) receivedmsg == OS_SC_RETRACE_MSG) { viUpdateMode(); - rdpCreateTask(var8005dcc8, var8005dcc8 + ARRAYCOUNT(var8005dcc8), 0, (s32) &scdonemsg); + rdpCreateTask(var8005dcc8, var8005dcc8 + ARRAYCOUNT(var8005dcc8), 0, (uintptr_t) &scdonemsg); j++; } } @@ -611,7 +611,7 @@ void mainInit(void) if (*(s16 *) receivedmsg == OS_SC_RETRACE_MSG) { viUpdateMode(); - rdpCreateTask(var8005dcc8, var8005dcc8 + ARRAYCOUNT(var8005dcc8), 0, (s32) &scdonemsg); + rdpCreateTask(var8005dcc8, var8005dcc8 + ARRAYCOUNT(var8005dcc8), 0, (uintptr_t) &scdonemsg); i++; } } @@ -1092,7 +1092,7 @@ void mainTick(void) viUpdateMode(); } - rdpCreateTask(gdlstart, gdl, 0, (s32) &msg); + rdpCreateTask(gdlstart, gdl, 0, (uintptr_t) &msg); g_MainNumGfxTasks++; memaPrint(); func0f16cf94(); diff --git a/src/lib/mema.c b/src/lib/mema.c index 7cbe894c0..e0dccdf14 100644 --- a/src/lib/mema.c +++ b/src/lib/mema.c @@ -400,7 +400,7 @@ void memaPrint(void) void *memaAlloc(u32 size) { - u32 addr; + uintptr_t addr; u32 diff; s32 i; diff --git a/src/lib/model.c b/src/lib/model.c index ee446a962..929f5c7b4 100644 --- a/src/lib/model.c +++ b/src/lib/model.c @@ -3853,10 +3853,10 @@ s32 modelTestForHit(struct model *model, struct coord *arg1, struct coord *arg2, if (var) \ var = (void *)((uintptr_t)var + diff) -void modelPromoteNodeOffsetsToPointers(struct modelnode *node, u32 vma, u32 fileramaddr) +void modelPromoteNodeOffsetsToPointers(struct modelnode *node, u32 vma, uintptr_t fileramaddr) { union modelrodata *rodata; - s32 diff = fileramaddr - vma; + uintptr_t diff = fileramaddr - vma; while (node) { u32 type = node->type & 0xff; @@ -3949,7 +3949,7 @@ void modelPromoteNodeOffsetsToPointers(struct modelnode *node, u32 vma, u32 file */ void modelPromoteOffsetsToPointers(struct modeldef *modeldef, u32 vma, uintptr_t fileramaddr) { - s32 diff = fileramaddr - vma; + uintptr_t diff = fileramaddr - vma; s32 i; s16 *partnums; diff --git a/src/lib/modelasm_c.c b/src/lib/modelasm_c.c index c443b9b91..ea24e12c8 100644 --- a/src/lib/modelasm_c.c +++ b/src/lib/modelasm_c.c @@ -1158,6 +1158,18 @@ static u32 modelasmReadFrameData(void) * Each value is the byte offset into the rodata struct where that node type's * rwdataindex property can be found, or 0xff is there is none. */ + +#ifdef PLATFORM_64BIT +u8 var8005ef90[] = { + 0xff, 0x08, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0x10, 0x2a, 0xff, 0x48, + 0x24, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x08, 0xff, + 0xff, 0xff, 0xff, 0x00, + 0x24, 0x00, +}; +#else u8 var8005ef90[] = { 0xff, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, @@ -1167,6 +1179,7 @@ u8 var8005ef90[] = { 0xff, 0xff, 0xff, 0x00, 0x14, 0x00, }; +#endif static union modelrwdata *modelasmGetNodeRwData(struct model *model, struct modelnode *node, bool is_head) { diff --git a/src/lib/rdp.c b/src/lib/rdp.c index f5c05f614..1782b372f 100644 --- a/src/lib/rdp.c +++ b/src/lib/rdp.c @@ -75,7 +75,7 @@ void rdpInit(void) g_RdpOutBufferEnd = (u16 *) ((uintptr_t) g_RdpOutBufferStart + size); } -void rdpCreateTask(Gfx *gdlstart, Gfx *gdlend, u32 arg2, s32 msg) +void rdpCreateTask(Gfx *gdlstart, Gfx *gdlend, u32 arg2, uintptr_t msg) { OSScTask *sctask; OSTask *task; diff --git a/src/lib/vi.c b/src/lib/vi.c index f76788821..992264dcb 100644 --- a/src/lib/vi.c +++ b/src/lib/vi.c @@ -220,7 +220,11 @@ void viReset(s32 stagenum) ptr = mempAlloc(fbsize * sizeof(u16) + 0x40, MEMPOOL_STAGE); +#ifdef PLATFORM_64BIT + ptr = (u8*)(((uintptr_t)ptr + 0x3f) & 0xffffffffffffffc0); +#else ptr = (u8 *)(((uintptr_t) ptr + 0x3f) & 0xffffffc0); +#endif g_FrameBuffers[0] = (u16 *) ptr; g_FrameBuffers[1] = (u16 *) (fbsize + ptr); From b0e6e8f24f3195e2fe3a9560a7fba1c7928d869c Mon Sep 17 00:00:00 2001 From: Raf <> Date: Thu, 11 Jul 2024 19:43:01 +0800 Subject: [PATCH 04/81] portx64: lots more u32 -> uintptr_t --- src/game/activemenu.c | 2 +- src/game/bg.c | 6 ++-- src/game/bondgun.c | 6 ++-- src/game/chr.c | 18 +++++------ src/game/dlights.c | 2 +- src/game/dyntex.c | 12 ++++---- src/game/filemgr.c | 4 +-- src/game/lang.c | 17 +++++----- src/game/mainmenu.c | 46 +++++++++++++-------------- src/game/menu.c | 22 ++++++++++++- src/game/menuitem.c | 2 +- src/game/modeldef.c | 6 ++-- src/game/modelmgr.c | 8 ++++- src/game/mplayer/ingame.c | 6 ++-- src/game/mplayer/scenarios.c | 6 ++-- src/game/mplayer/setup.c | 60 ++++++++++++++++++------------------ src/game/objectives.c | 2 +- src/game/player.c | 4 +++ src/game/playerreset.c | 7 ++++- src/game/propobj.c | 8 ++--- src/game/stars.c | 2 +- src/game/texdecompress.c | 4 +-- src/game/trainingmenus.c | 22 ++++++------- src/include/types.h | 8 +++-- src/lib/main.c | 2 +- 25 files changed, 161 insertions(+), 121 deletions(-) diff --git a/src/game/activemenu.c b/src/game/activemenu.c index bc984de99..e1dde59a7 100644 --- a/src/game/activemenu.c +++ b/src/game/activemenu.c @@ -177,7 +177,7 @@ MenuItemHandlerResult amPickTargetMenuList(s32 operation, struct menuitem *item, gdl = text0f153628(gdl); gdl = textRenderProjected(gdl, &x, &y, g_MpAllChrConfigPtrs[chrindex]->name, g_CharsHandelGothicSm, g_FontHandelGothicSm, colour, viGetWidth(), viGetHeight(), 0, 0); gdl = text0f153780(gdl); - return (s32)gdl; + return (uintptr_t)gdl; } case MENUOP_GETOPTIONHEIGHT: data->list.value = LINEHEIGHT; diff --git a/src/game/bg.c b/src/game/bg.c index c6dddc699..6ca79a5de 100644 --- a/src/game/bg.c +++ b/src/game/bg.c @@ -97,7 +97,7 @@ u16 g_BgUnloadDelay240; u16 g_BgUnloadDelay240_2; u32 var800a4bf4; RoomNum g_GlareRooms[100]; -u32 *g_BgPrimaryData2; +uintptr_t *g_BgPrimaryData2; struct bgroom *g_BgRooms; struct bgportal *g_BgPortals; struct portalmetric *g_PortalMetrics; @@ -2937,7 +2937,7 @@ void bgLoadRoom(s32 roomnum) // Copy gdls to the right-side of the allocation // and build a pointer array to them - texCopyGdls((void *) gfxblocks[0], (void *) (allocation + alloclen - (gfxblocks[numgdls] - gfxblocks[0])), (u32) (gfxblocks[numgdls] - gfxblocks[0])); + texCopyGdls((void *) gfxblocks[0], (void *) (allocation + alloclen - (gfxblocks[numgdls] - gfxblocks[0])), (uintptr_t) (gfxblocks[numgdls] - gfxblocks[0])); for (i = 0; i < numgdls + 1; i++) { gdlpointers[i] = gfxblocks[i] + (allocation + alloclen - gfxblocks[numgdls]); @@ -4243,7 +4243,7 @@ bool bgTestHitInVtxBatch(struct coord *arg0, struct coord *arg1, struct coord *a vtx = bgFindVerticesForGdl(roomnum, gdl); iter = &gdl[batch->gbicmdindex]; - vtx = (Vtx *)((UNSEGADDR(iter->words.w1) & 0xffffff) + (s32)vtx); + vtx = (Vtx *)((UNSEGADDR(iter->words.w1) & 0xffffff) + (uintptr_t)vtx); numvertices = (((u32) iter->bytes[GFX_W0_BYTE(1)] >> 4) & 0xf) + 1; ptr = var800a6470; diff --git a/src/game/bondgun.c b/src/game/bondgun.c index e6fc19619..1bfe79cc3 100644 --- a/src/game/bondgun.c +++ b/src/game/bondgun.c @@ -3798,13 +3798,13 @@ void bgunTickGunLoad(void) s32 padding; u32 allocsize; u32 loadsize; - u32 ptr; + uintptr_t ptr; struct player *player = g_Vars.currentplayer; struct modeldef *modeldef; struct fileinfo *fileinfo; struct fileinfo *gunfileinfo; s32 newvalue; - u32 end; + uintptr_t end; u32 stack; #if VERSION >= VERSION_NTSC_1_0 u32 stack2; @@ -3854,7 +3854,7 @@ void bgunTickGunLoad(void) fileinfo = &g_FileInfo[player->gunctrl.loadfilenum]; fileinfo->allocsize = allocsize; - end = ALIGN16((s32)ptr + allocsize); + end = ALIGN16((uintptr_t)ptr + allocsize); allocsize = end - ptr; if (1); remaining -= allocsize; diff --git a/src/game/chr.c b/src/game/chr.c index c037e9a3a..0cb5c8059 100644 --- a/src/game/chr.c +++ b/src/game/chr.c @@ -3866,13 +3866,13 @@ void chr0f0260c4(struct model *model, s32 hitpart, struct modelnode *node, struc } if (rwdata->gdl == rodata->opagdl) { - gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((u32)UNSEGADDR(rodata->opagdl) & 0xffffff)); + gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->opagdl) & 0xffffff)); } else { gdlptr = rwdata->gdl; } if (rodata->xlugdl) { - gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((u32)UNSEGADDR(rodata->xlugdl) & 0xffffff)); + gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->xlugdl) & 0xffffff)); } else { gdlptr2 = NULL; } @@ -4026,13 +4026,13 @@ void chrBruise(struct model *model, s32 hitpart, struct modelnode *node, struct // use the space... after the model definition's colour table? // Let's hope that's not being used by other instances... if (rwdata->gdl == rodata->opagdl) { - gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((u32)UNSEGADDR(rodata->opagdl) & 0xffffff)); + gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->opagdl) & 0xffffff)); } else { gdlptr = rwdata->gdl; } if (rodata->xlugdl) { - gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((u32)UNSEGADDR(rodata->xlugdl) & 0xffffff)); + gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->xlugdl) & 0xffffff)); } else { gdlptr2 = NULL; } @@ -4168,13 +4168,13 @@ void chrBruise(struct model *model, s32 hitpart, struct modelnode *node, struct } if (rwdata->gdl == rodata->opagdl) { - gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((u32)UNSEGADDR(rodata->opagdl) & 0xffffff)); + gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->opagdl) & 0xffffff)); } else { gdlptr = rwdata->gdl; } if (rodata->xlugdl) { - gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((u32)UNSEGADDR(rodata->xlugdl) & 0xffffff)); + gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->xlugdl) & 0xffffff)); } else { gdlptr2 = NULL; } @@ -4216,7 +4216,7 @@ void chrBruise(struct model *model, s32 hitpart, struct modelnode *node, struct coordinate = vertices[i].z + (s32)spd4.f[2]; if (coordinate == bestcoords[2]) { - if ((uintptr_t)rwdata->colours == ALIGN8((u32)rodata->vertices + rodata->numvertices * sizeof(Vtx))) { + if ((uintptr_t)rwdata->colours == ALIGN8((uintptr_t)rodata->vertices + rodata->numvertices * sizeof(Vtx))) { Col *colours = vtxstoreAllocate(rodata->numcolours, VTXSTORETYPE_CHRCOL, 0, 0); s32 j; @@ -4363,13 +4363,13 @@ void chrDisfigure(struct chrdata *chr, struct coord *exppos, f32 damageradius) if (rwdata->vertices != rodata->vertices && (uintptr_t)rwdata->colours != ALIGN8((uintptr_t)&rodata->vertices[rodata->numvertices])) { if (rwdata->gdl == rodata->opagdl) { - gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((s32)UNSEGADDR(rodata->opagdl) & 0xffffff)); + gdlptr = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->opagdl) & 0xffffff)); } else { gdlptr = rwdata->gdl; } if (rodata->xlugdl) { - gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((s32)UNSEGADDR(rodata->xlugdl) & 0xffffff)); + gdlptr2 = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->xlugdl) & 0xffffff)); } else { gdlptr2 = NULL; } diff --git a/src/game/dlights.c b/src/game/dlights.c index c00836a0a..018f3e4e4 100644 --- a/src/game/dlights.c +++ b/src/game/dlights.c @@ -1049,7 +1049,7 @@ bool lightTickBroken(s32 roomnum, s32 lightnum) lightGetBboxCentre(roomnum, lightnum, ¢re); - room = (void *) ((u8 *) g_BgRooms + (u32) room); + room = (void *) ((u8 *) g_BgRooms + (uintptr_t) room); centre.x += room->pos.x; centre.y += room->pos.y; centre.z += room->pos.z; diff --git a/src/game/dyntex.c b/src/game/dyntex.c index 97ebf827c..f132f6cc7 100644 --- a/src/game/dyntex.c +++ b/src/game/dyntex.c @@ -79,7 +79,7 @@ void dyntexUpdateLinear(Vtx *vertices, struct dyntextype *type) s32 i; for (i = 0; i < type->numvertices; i++) { - Vtx *vertex = (Vtx *)((s32)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); + Vtx *vertex = (Vtx *)((uintptr_t)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); vertex->t = g_DyntexVertices[type->vertexlistoffset + i].t + tmp; vertex->s = g_DyntexVertices[type->vertexlistoffset + i].s; @@ -91,7 +91,7 @@ void dyntexUpdateReset(Vtx *vertices, struct dyntextype *type) s32 i; for (i = 0; i < type->numvertices; i++) { - Vtx *vertex = (Vtx *)((s32)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); + Vtx *vertex = (Vtx *)((uintptr_t)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); vertex->s = 0; vertex->t = 0; @@ -104,7 +104,7 @@ void dyntexUpdateMonitor(Vtx *vertices, struct dyntextype *type) s32 i; for (i = 0; i < type->numvertices; i++) { - Vtx *vertex = (Vtx *)((s32)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); + Vtx *vertex = (Vtx *)((uintptr_t)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); vertex->t = g_DyntexVertices[type->vertexlistoffset + i].t - tmp; vertex->s = g_DyntexVertices[type->vertexlistoffset + i].s; @@ -124,7 +124,7 @@ void dyntexUpdateOcean(Vtx *vertices, struct dyntextype *type) mainOverrideVariable("ripsize", &ripsize); for (i = 0; i < type->numvertices; i++) { - Vtx *vertex = (Vtx *)((s32)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); + Vtx *vertex = (Vtx *)((uintptr_t)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); angle = ((g_DyntexVertices[type->vertexlistoffset + i].t % modula) / (f32) modula + f24) * M_BADTAU; vertex->t = g_DyntexVertices[type->vertexlistoffset + i].t + (s16) (sinf(angle) * ripsize); @@ -140,7 +140,7 @@ void dyntexUpdateArrows(Vtx *vertices, struct dyntextype *type) s32 i; for (i = 0; i < type->numvertices; i++) { - Vtx *vertex = (Vtx *)((s32)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); + Vtx *vertex = (Vtx *)((uintptr_t)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); vertex->s = g_DyntexVertices[type->vertexlistoffset + i].s + tmp; vertex->t = g_DyntexVertices[type->vertexlistoffset + i].t; @@ -182,7 +182,7 @@ void dyntexTickRoom(s32 roomnum, Vtx *vertices) // @bug: Using i for both outer and inner loops for (i = 0; i < type->numvertices; i++) { - Vtx *vertex = (Vtx *)((s32)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); + Vtx *vertex = (Vtx *)((uintptr_t)vertices + g_DyntexVertices[type->vertexlistoffset + i].offset); g_DyntexVertices[type->vertexlistoffset + i].s = vertex->s; g_DyntexVertices[type->vertexlistoffset + i].t = vertex->t; diff --git a/src/game/filemgr.c b/src/game/filemgr.c index aac819ad1..544c3b82d 100644 --- a/src/game/filemgr.c +++ b/src/game/filemgr.c @@ -428,7 +428,7 @@ s32 filemgrGetDeviceNameOrStartIndex(s32 listnum, s32 operation, s32 optionindex if (g_FileLists[listnum]->devicestartindexes[i] != -1) { if (remaining == 0) { if (operation == MENUOP_GETOPTGROUPTEXT) { - return (s32)langGet(names[i]); + return (uintptr_t)langGet(names[i]); } return g_FileLists[listnum]->devicestartindexes[i]; @@ -1252,7 +1252,7 @@ void func0f1097d0(s32 device) thing = memaAlloc(align16(g_FileTypeSizes[g_Menus[g_MpPlayerNum].fm.filetypeplusone - 1])); if (thing) { - filemgrSaveOrLoad(&g_FilemgrFileToCopy, g_Menus[g_MpPlayerNum].fm.filetypeplusone + 103, (s32) thing); + filemgrSaveOrLoad(&g_FilemgrFileToCopy, g_Menus[g_MpPlayerNum].fm.filetypeplusone + 103, (uintptr_t) thing); } else { filemgrPushErrorDialog(FILEERROR_OUTOFMEMORY); } diff --git a/src/game/lang.c b/src/game/lang.c index b2e595371..a1e672d9f 100644 --- a/src/game/lang.c +++ b/src/game/lang.c @@ -59,12 +59,12 @@ bool g_Jpn = VERSION == VERSION_JPN_FINAL ? true : false; u8 *g_LangBuffer = NULL; u8 *g_LangBufferPos = NULL; s32 g_LangBufferSize = 0; -u32 *g_LangBanks[69]; +uintptr_t *g_LangBanks[69]; struct jpncharpixels *g_JpnCharCachePixels; struct jpncacheitem *g_JpnCacheCacheItems; s32 g_LanguageId = LANGUAGE_NTSC_EN; #else -u32 *g_LangBanks[69]; +uintptr_t *g_LangBanks[69]; struct jpncharpixels *g_JpnCharCachePixels; struct jpncacheitem *g_JpnCacheCacheItems; bool g_Jpn = false; @@ -379,11 +379,11 @@ void langLoad(s32 bank) #if VERSION >= VERSION_PAL_BETA s32 len = fileGetInflatedSize(langGetFileId(bank)); - if ((s32)g_LangBuffer + len + g_LangBufferSize - (s32)g_LangBufferPos >= 0) { - s32 len2 = (s32)g_LangBuffer + g_LangBufferSize - (s32)g_LangBufferPos; + if ((uintptr_t)g_LangBuffer + len + g_LangBufferSize - (uintptr_t)g_LangBufferPos >= 0) { + s32 len2 = (uintptr_t)g_LangBuffer + g_LangBufferSize - (uintptr_t)g_LangBufferPos; len2 = len2 / 32 * 32; g_LangBanks[bank] = fileLoadToAddr(langGetFileId(bank), FILELOADMETHOD_DEFAULT, (u8 *)g_LangBufferPos, len2); - g_LangBufferPos = (u8 *)(align32((s32)g_LangBufferPos + len)); + g_LangBufferPos = (u8 *)(align32((uintptr_t)g_LangBufferPos + len)); } else { CRASH(); } @@ -418,11 +418,12 @@ char *langGet(s32 textid) { s32 bankindex = textid >> 9; s32 textindex = textid & 0x1ff; - u32 *bank = g_LangBanks[bankindex]; - u32 addr; + uintptr_t *bank = g_LangBanks[bankindex]; + uintptr_t addr; if (bank && bank[textindex]) { - addr = (uintptr_t)bank + PD_BE32(bank[textindex]); +// addr = (uintptr_t)bank + PD_BE32(bank[textindex]); + addr = (u8*)bank + (bank[textindex]); } else { addr = 0; } diff --git a/src/game/mainmenu.c b/src/game/mainmenu.c index 663e6160e..a69146c96 100644 --- a/src/game/mainmenu.c +++ b/src/game/mainmenu.c @@ -99,15 +99,15 @@ MenuItemHandlerResult menuhandlerControlStyleImpl(s32 operation, struct menuitem break; case MENUOP_GETOPTIONTEXT: if (data->list.value > 7) { - return (intptr_t) "Ext"; + return (uintptr_t) "Ext"; } else { - return (intptr_t) langGet(g_ControlStyleOptions[data->list.value]); + return (uintptr_t) langGet(g_ControlStyleOptions[data->list.value]); } case MENUOP_GETOPTGROUPTEXT: if (data->list.value > 1) { - return (intptr_t) "Port"; + return (uintptr_t) "Port"; } else { - return (intptr_t) langGet(categories[data->list.value]); + return (uintptr_t) langGet(categories[data->list.value]); } case MENUOP_GETGROUPSTARTINDEX: data->list.groupstartindex = data->list.value * 4; @@ -193,9 +193,9 @@ MenuItemHandlerResult menuhandlerAimControl(s32 operation, struct menuitem *item break; case MENUOP_GETOPTIONTEXT: #if VERSION >= VERSION_PAL_FINAL - return (s32) langGet(options[index][data->dropdown.value]); + return (uintptr_t) langGet(options[index][data->dropdown.value]); #else - return (s32) langGet(options[data->dropdown.value]); + return (uintptr_t) langGet(options[data->dropdown.value]); #endif case MENUOP_SET: optionsSetAimControl(playernum, data->dropdown.value); @@ -222,7 +222,7 @@ MenuItemHandlerResult menuhandlerSoundMode(s32 operation, struct menuitem *item, data->dropdown.value = 4; break; case MENUOP_GETOPTIONTEXT: - return (s32) langGet(options[data->dropdown.value]); + return (uintptr_t) langGet(options[data->dropdown.value]); case MENUOP_SET: sndSetSoundMode(data->dropdown.value); g_Vars.modifiedfiles |= MODFILE_GAME; @@ -247,7 +247,7 @@ MenuItemHandlerResult menuhandlerScreenSize(s32 operation, struct menuitem *item data->dropdown.value = 3; break; case MENUOP_GETOPTIONTEXT: - return (s32) langGet(options[data->dropdown.value]); + return (uintptr_t) langGet(options[data->dropdown.value]); case MENUOP_SET: optionsSetScreenSize(data->dropdown.value); g_Vars.modifiedfiles |= MODFILE_GAME; @@ -271,7 +271,7 @@ MenuItemHandlerResult menuhandlerScreenRatio(s32 operation, struct menuitem *ite data->dropdown.value = 2; break; case MENUOP_GETOPTIONTEXT: - return (s32) langGet(options[data->dropdown.value]); + return (uintptr_t) langGet(options[data->dropdown.value]); case MENUOP_SET: optionsSetScreenRatio(data->dropdown.value); g_Vars.modifiedfiles |= MODFILE_GAME; @@ -299,7 +299,7 @@ MenuItemHandlerResult menuhandlerLanguage(s32 operation, struct menuitem *item, data->dropdown.value = 5; break; case MENUOP_GETOPTIONTEXT: - return (s32)langGet(labels[data->dropdown.value]); + return (uintptr_t)langGet(labels[data->dropdown.value]); case MENUOP_SET: g_Vars.language = data->dropdown.value; langSetEuropean(g_Vars.language); @@ -330,7 +330,7 @@ MenuItemHandlerResult menuhandlerScreenSplit(s32 operation, struct menuitem *ite data->dropdown.value = 2; break; case MENUOP_GETOPTIONTEXT: - return (s32) langGet(options[data->dropdown.value]); + return (uintptr_t) langGet(options[data->dropdown.value]); case MENUOP_SET: if (data->dropdown.value != (u32)optionsGetScreenSplit()) { optionsSetScreenSplit(data->dropdown.value); @@ -1429,7 +1429,7 @@ MenuItemHandlerResult menuhandlerCoopBuddy(s32 operation, struct menuitem *item, extra = 0; } - return (s32)langGet(labels[data->dropdown.value + extra]); + return (uintptr_t)langGet(labels[data->dropdown.value + extra]); } case MENUOP_SET: { @@ -1546,7 +1546,7 @@ MenuItemHandlerResult menuhandlerAntiPlayer(s32 operation, struct menuitem *item data->dropdown.value = 2; break; case MENUOP_GETOPTIONTEXT: - return (s32) langGet(labels[data->dropdown.value]); + return (uintptr_t) langGet(labels[data->dropdown.value]); case MENUOP_SET: g_Vars.pendingantiplayernum = data->dropdown.value; g_Vars.modifiedfiles |= MODFILE_GAME; @@ -1892,11 +1892,11 @@ MenuItemHandlerResult menuhandlerMissionList(s32 operation, struct menuitem *ite if (data->list.value < data->list.unk04u32) { // Regular stage such as "dataDyne Central - Defection" // Return the name before the dash, such as "dataDyne Central" - return (s32) langGet(g_SoloStages[data->list.value].name1); + return (uintptr_t) langGet(g_SoloStages[data->list.value].name1); } // Special stages have no dash and suffix, so just return the name - return (s32) langGet(g_SoloStages[func0f104720(data->list.value - data->list.unk04u32)].name1); + return (uintptr_t) langGet(g_SoloStages[func0f104720(data->list.value - data->list.unk04u32)].name1); case MENUOP_SET: sp188 = data->list.value; menuhandlerMissionList(MENUOP_GETOPTIONCOUNT, item, &sp178); @@ -1959,9 +1959,9 @@ MenuItemHandlerResult menuhandlerMissionList(s32 operation, struct menuitem *ite break; case MENUOP_GETOPTGROUPTEXT: if (data->list.unk0c == data->list.value) { - return (s32) langGet(groups[9].name); // "Special Assignments" + return (uintptr_t) langGet(groups[9].name); // "Special Assignments" } - return (s32) langGet(groups[data->list.value].name); + return (uintptr_t) langGet(groups[data->list.value].name); case MENUOP_GETGROUPSTARTINDEX: if (data->list.unk0c == data->list.value) { menuhandlerMissionList(MENUOP_GETOPTIONCOUNT, item, &sp13c); @@ -2105,7 +2105,7 @@ MenuItemHandlerResult menuhandlerMissionList(s32 operation, struct menuitem *ite gdl = text0f153780(gdl); - return (s32) gdl; + return (uintptr_t) gdl; case MENUOP_GETOPTIONHEIGHT: data->list.value = 42; break; @@ -4255,7 +4255,7 @@ MenuItemHandlerResult menuhandlerFrInventoryList(s32 operation, struct menuitem break; case MENUOP_GETOPTIONTEXT: g_FrFocusedSlotIndex = data->list.value; - return (s32)bgunGetName(frGetWeaponBySlot(data->list.value)); + return (uintptr_t)bgunGetName(frGetWeaponBySlot(data->list.value)); case MENUOP_SET: g_FrFocusedSlotIndex = data->list.value; return 0; @@ -4285,7 +4285,7 @@ MenuItemHandlerResult menuhandlerInventoryList(s32 operation, struct menuitem *i data->list.value = invGetCount(); break; case MENUOP_GETOPTIONTEXT: - return (s32)invGetNameByIndex(data->list.value); + return (uintptr_t)invGetNameByIndex(data->list.value); case MENUOP_SET: { s32 weaponnum = invGetWeaponNumByIndex(data->list.value); @@ -4723,9 +4723,9 @@ MenuItemHandlerResult menuhandlerCinema(s32 operation, struct menuitem *item, un case MENUOP_GETOPTIONTEXT: if (data->list.value == 0) { sprintf(g_StringPointer, langGet(L_OPTIONS_448)); // "Play All" - return (s32) g_StringPointer; + return (uintptr_t) g_StringPointer; } - return (s32) langGet(g_Cutscenes[data->list.value - 1].name); + return (uintptr_t) langGet(g_Cutscenes[data->list.value - 1].name); case MENUOP_SET: if (data->list.value == 0) { // Play all @@ -4749,7 +4749,7 @@ MenuItemHandlerResult menuhandlerCinema(s32 operation, struct menuitem *item, un data->list.value = ARRAYCOUNT(groups); break; case MENUOP_GETOPTGROUPTEXT: - return (s32) langGet(groups[data->list.value].name); + return (uintptr_t) langGet(groups[data->list.value].name); case MENUOP_GETGROUPSTARTINDEX: data->list.groupstartindex = groups[data->list.value].first_cutscene_index; break; diff --git a/src/game/menu.c b/src/game/menu.c index 26c839f0a..2f3441964 100644 --- a/src/game/menu.c +++ b/src/game/menu.c @@ -475,7 +475,7 @@ char *menuResolveText(uintptr_t thing, void *dialogoritem) // Text ID if (thing < 0x5a00) { - return langGet((u32)thing); + return langGet((uintptr_t)thing); } #ifdef PLATFORM_N64 // unreliable otherwise, the above check should be enough? @@ -1880,7 +1880,11 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) totalfilelen += ALIGN64(fileGetInflatedSize(headfilenum)); } +#ifdef PLATFORM_64BIT + totalfilelen += 0x6000; +#else totalfilelen += 0x4000; +#endif texInitPool(&texpool, menumodel->allocstart + totalfilelen, menumodel->alloclen - totalfilelen); @@ -1902,7 +1906,11 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) modelInit(&menumodel->bodymodel, menumodel->bodymodeldef, menumodel->rwdata, true); animInit(&menumodel->bodyanim); +#ifdef PLATFORM_64BIT + menumodel->bodymodel.rwdatalen = 256 + 128; +#else menumodel->bodymodel.rwdatalen = 256; +#endif menumodel->bodymodel.anim = &menumodel->bodyanim; body0f02ce8c(bodynum, headnum, menumodel->bodymodeldef, menumodel->headmodeldef, totalfilelen * 0, &menumodel->bodymodel, false, 1); @@ -1921,7 +1929,11 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) modelInit(&menumodel->bodymodel, menumodel->bodymodeldef, menumodel->rwdata, true); animInit(&menumodel->bodyanim); +#ifdef PLATFORM_64BIT + menumodel->bodymodel.rwdatalen = 256+128; +#else menumodel->bodymodel.rwdatalen = 256; +#endif menumodel->bodymodel.anim = &menumodel->bodyanim; } @@ -3891,11 +3903,19 @@ void menuReset(void) } for (i = 0; i < max; i++) { +#ifdef PLATFORM_64BIT + menuResetModel(&g_Menus[i].menumodel, IS4MB() ? 0xb400 : 0x38400, true); // 50% more +#else menuResetModel(&g_Menus[i].menumodel, IS4MB() ? 0xb400 : 0x25800, true); +#endif } if (IS8MB()) { +#ifdef PLATFORM_64BIT + menuResetModel(&g_MenuData.hudpiece, 0x12c00, true); // 50% more +#else menuResetModel(&g_MenuData.hudpiece, 0xc800, true); +#endif } g_MenuData.hudpiece.newparams = MENUMODELPARAMS_SET_FILENUM(FILE_GHUDPIECE); diff --git a/src/game/menuitem.c b/src/game/menuitem.c index f06218f30..df2216b42 100644 --- a/src/game/menuitem.c +++ b/src/game/menuitem.c @@ -1884,7 +1884,7 @@ Gfx *menuitemModelRender(Gfx *gdl, struct menurendercontext *context) renderdata.unk10 = true; data.type19.gdl = gdl; - data.type19.unk04 = (s32)&renderdata; + data.type19.unk04 = (uintptr_t)&renderdata; data.type19.renderdata2 = &renderdata; gdl = (Gfx *)context->item->handler(MENUOP_RENDER, context->item, &data); diff --git a/src/game/modeldef.c b/src/game/modeldef.c index 0d0913ff7..42f5d97a4 100644 --- a/src/game/modeldef.c +++ b/src/game/modeldef.c @@ -131,12 +131,12 @@ void modeldef0f1a7560(struct modeldef *modeldef, u16 filenum, u32 arg2, struct m s5 = gdl; if (gdl) { - s32 v1 = allocsize - (loadedsize - (s32)(((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff)) - (uintptr_t)modeldef)); - sp84 = (s32)v1 + (s32)((uintptr_t)modeldef - ((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff))); + s32 v1 = allocsize - (loadedsize - (uintptr_t)(((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff)) - (uintptr_t)modeldef)); + sp84 = (uintptr_t)v1 + (uintptr_t)((uintptr_t)modeldef - ((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff))); texCopyGdls((Gfx *)((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff)), (Gfx *)(v1 + (uintptr_t)modeldef), - loadedsize - (s32)(((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff)) - (uintptr_t)modeldef)); + loadedsize - (uintptr_t)(((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff)) - (uintptr_t)modeldef)); texLoadFromConfigs(modeldef->texconfigs, modeldef->numtexconfigs, texpool, (uintptr_t)modeldef2 - arg2); while (node) { diff --git a/src/game/modelmgr.c b/src/game/modelmgr.c index 5251e8d58..d6bec4876 100644 --- a/src/game/modelmgr.c +++ b/src/game/modelmgr.c @@ -7,6 +7,8 @@ #include "data.h" #include "types.h" +#include "system.h" + struct model *g_ModelSlots; struct anim *g_AnimSlots; s32 g_ModelNumObjs; @@ -204,7 +206,7 @@ struct model *modelmgrInstantiateModel(struct modeldef *modeldef, bool withanim) } } } else { - // empty + sysLogPrintf(LOG_WARNING, "Unable to allocate rwdata"); } if (withanim) { @@ -213,6 +215,10 @@ struct model *modelmgrInstantiateModel(struct modeldef *modeldef, bool withanim) datalen = IS4MB() ? 52 : 256; } +#ifdef PLATFORM_64BIT + datalen += 128; +#endif + if (datalen < modeldef->rwdatalen) { datalen = modeldef->rwdatalen; } diff --git a/src/game/mplayer/ingame.c b/src/game/mplayer/ingame.c index ef96daa54..a4bef3f21 100644 --- a/src/game/mplayer/ingame.c +++ b/src/game/mplayer/ingame.c @@ -53,14 +53,14 @@ MenuItemHandlerResult mpStatsForPlayerDropdownHandler(s32 operation, struct menu mpchr = MPCHR(a1); if (v0 == data->list.value) { - return (s32) mpchr->name; + return (uintptr_t) mpchr->name; } v0++; } } - return (s32) ""; + return (uintptr_t) ""; case MENUOP_SET: v0 = 0; @@ -698,7 +698,7 @@ MenuItemHandlerResult mpAwardsMenuHandler(s32 operation, struct menuitem *item, } } - return (s32) gdl; + return (uintptr_t) gdl; } return 0; diff --git a/src/game/mplayer/scenarios.c b/src/game/mplayer/scenarios.c index aa502ed21..60a4f85f5 100644 --- a/src/game/mplayer/scenarios.c +++ b/src/game/mplayer/scenarios.c @@ -141,7 +141,7 @@ MenuItemHandlerResult menuhandlerMpSlowMotion(s32 operation, struct menuitem *it data->dropdown.value = 3; break; case MENUOP_GETOPTIONTEXT: - return (s32)langGet(labels[data->dropdown.value]); + return (uintptr_t)langGet(labels[data->dropdown.value]); case MENUOP_SET: g_MpSetup.options &= ~(MPOPTION_SLOWMOTION_ON | MPOPTION_SLOWMOTION_SMART); @@ -338,7 +338,7 @@ MenuItemHandlerResult scenarioScenarioMenuHandler(s32 operation, struct menuitem if (challengeIsFeatureUnlocked(g_MpScenarioOverviews[i].requirefeature) && (teamgame || g_MpScenarioOverviews[i].teamonly == false)) { if (count == data->list.value) { - return (s32)langGet(g_MpScenarioOverviews[i].name); + return (uintptr_t)langGet(g_MpScenarioOverviews[i].name); } count++; @@ -383,7 +383,7 @@ MenuItemHandlerResult scenarioScenarioMenuHandler(s32 operation, struct menuitem } break; case MENUOP_GETOPTGROUPTEXT: - return (s32)langGet(groups[data->list.value].textid); + return (uintptr_t)langGet(groups[data->list.value].textid); case MENUOP_GETGROUPSTARTINDEX: for (i = 0; i < groups[data->list.value].startindex; i++) { if (challengeIsFeatureUnlocked(g_MpScenarioOverviews[i].requirefeature) diff --git a/src/game/mplayer/setup.c b/src/game/mplayer/setup.c index 44834bbfb..646319f34 100644 --- a/src/game/mplayer/setup.c +++ b/src/game/mplayer/setup.c @@ -177,7 +177,7 @@ MenuItemHandlerResult mpArenaMenuHandler(s32 operation, struct menuitem *item, u for (i = 0; i < ARRAYCOUNT(g_MpArenas); i++) { if (challengeIsFeatureUnlocked(g_MpArenas[i].requirefeature)) { if (count == data->list.value) { - return (s32)langGet(g_MpArenas[i].name); + return (uintptr_t)langGet(g_MpArenas[i].name); } count++; @@ -226,7 +226,7 @@ MenuItemHandlerResult mpArenaMenuHandler(s32 operation, struct menuitem *item, u && count > 0) { count++; } - return (s32)langGet(groups[count].name); + return (uintptr_t)langGet(groups[count].name); case MENUOP_GETGROUPSTARTINDEX: groupindex = data->list.value; @@ -288,7 +288,7 @@ MenuItemHandlerResult menuhandlerMpWeaponSlot(s32 operation, struct menuitem *it data->dropdown.value = mpGetNumWeaponOptions(); break; case MENUOP_GETOPTIONTEXT: - return (s32) mpGetWeaponLabel(data->dropdown.value); + return (uintptr_t) mpGetWeaponLabel(data->dropdown.value); case MENUOP_SET: mpSetWeaponSlot(item->param3, data->dropdown.value); break; @@ -311,7 +311,7 @@ MenuItemHandlerResult menuhandlerMpWeaponSetDropdown(s32 operation, struct menui data->dropdown.value = func0f189058(item->param); break; case MENUOP_GETOPTIONTEXT: - return (s32) mpGetWeaponSetName(data->dropdown.value); + return (uintptr_t) mpGetWeaponSetName(data->dropdown.value); case MENUOP_SET: mpSetWeaponSet(data->dropdown.value); break; @@ -377,7 +377,7 @@ MenuItemHandlerResult menuhandlerMpAimControl(s32 operation, struct menuitem *it data->dropdown.value = 2; break; case MENUOP_GETOPTIONTEXT: - return (s32) langGet(labels[data->dropdown.value]); + return (uintptr_t) langGet(labels[data->dropdown.value]); case MENUOP_SET: optionsSetAimControl(g_MpPlayerNum, data->dropdown.value); break; @@ -767,7 +767,7 @@ MenuItemHandlerResult mpChallengesListHandler(s32 operation, struct menuitem *it loopx += 13; } - return (s32) gdl; + return (uintptr_t) gdl; case MENUOP_GETOPTIONHEIGHT: data->list.value = 26; break; @@ -1001,7 +1001,7 @@ MenuItemHandlerResult mpMedalMenuHandler(s32 operation, struct menuitem *item, u ((renderdata->x + 20) << 2) * g_ScaleX, (renderdata->y + 11) << 2, G_TX_RENDERTILE, 0, 0x0160, 1024 / g_ScaleX, -1024); - return (s32) gdl; + return (uintptr_t) gdl; } return 0; @@ -2082,11 +2082,11 @@ MenuItemHandlerResult mpLoadSettingsMenuHandler(s32 operation, struct menuitem * break; case MENUOP_GETOPTIONTEXT: if (data->list.value < mpGetNumUnlockedPresets()) { - return (s32)mpGetPresetNameBySlot(data->list.value); + return (uintptr_t)mpGetPresetNameBySlot(data->list.value); } if (g_FileLists[1] != NULL) { func0f0d564c(g_FileLists[1]->files[data->list.value - mpGetNumUnlockedPresets()].name, g_StringPointer, false); - return (s32)g_StringPointer; + return (uintptr_t)g_StringPointer; } break; case MENUOP_SET: @@ -2124,10 +2124,10 @@ MenuItemHandlerResult mpLoadSettingsMenuHandler(s32 operation, struct menuitem * break; case MENUOP_GETOPTGROUPTEXT: if (data->list.value == 0) { - return (s32)langGet(L_MPMENU_141); // "Presets" + return (uintptr_t)langGet(L_MPMENU_141); // "Presets" } if (g_FileLists[1] != NULL) { - return (s32)filemgrGetDeviceNameOrStartIndex(1, operation, data->list.value - 1); + return (uintptr_t)filemgrGetDeviceNameOrStartIndex(1, operation, data->list.value - 1); } break; case MENUOP_GETGROUPSTARTINDEX: @@ -2221,7 +2221,7 @@ MenuItemHandlerResult mpLoadPlayerMenuHandler(s32 operation, struct menuitem *it break; case MENUOP_GETOPTIONTEXT: filemgrGetSelectName(g_StringPointer, &g_FileLists[0]->files[data->list.value], FILETYPE_MPPLAYER); - return (s32)g_StringPointer; + return (uintptr_t)g_StringPointer; case MENUOP_SET: file = &g_FileLists[0]->files[data->list.value]; available = true; @@ -2742,7 +2742,7 @@ MenuItemHandlerResult mpAddChangeSimulantMenuHandler(s32 operation, struct menui for (i = 0; i < ARRAYCOUNT(g_BotProfiles); i++) { if (challengeIsFeatureUnlocked(g_BotProfiles[i].requirefeature)) { if (count == data->list.value) { - return (s32)langGet(g_BotProfiles[i].name); + return (uintptr_t)langGet(g_BotProfiles[i].name); } count++; @@ -2803,7 +2803,7 @@ MenuItemHandlerResult mpAddChangeSimulantMenuHandler(s32 operation, struct menui data->list.value = 2; break; case MENUOP_GETOPTGROUPTEXT: - return (s32)langGet(groups[data->list.value].name); + return (uintptr_t)langGet(groups[data->list.value].name); case MENUOP_GETGROUPSTARTINDEX: for (i = 0; i < groups[data->list.value].offset; i++) { if (challengeIsFeatureUnlocked(g_BotProfiles[i].requirefeature)) { @@ -2910,14 +2910,14 @@ MenuItemHandlerResult mpBotDifficultyMenuHandler(s32 operation, struct menuitem if (challengeIsFeatureUnlocked(g_BotProfiles[i].requirefeature)) { if (count == data->dropdown.value) { // "Meat", "Easy", "Normal" etc - return (s32) langGet(L_MISC_082 + i); + return (uintptr_t) langGet(L_MISC_082 + i); } count++; } } - return (s32)"\n"; + return (uintptr_t)"\n"; } return 0; @@ -3481,10 +3481,10 @@ MenuItemHandlerResult func0f17dac4(s32 operation, struct menuitem *item, union h break; case MENUOP_GETOPTIONTEXT: if ((g_MpSetup.options & MPOPTION_TEAMSENABLED) == 0) { - return (s32) "\n"; + return (uintptr_t) "\n"; } - return (s32) g_BossFile.teamnames[data->list.value]; + return (uintptr_t) g_BossFile.teamnames[data->list.value]; } return menuhandlerMpTeamsLabel(operation, item, data); @@ -3913,14 +3913,14 @@ MenuItemHandlerResult mpSelectTuneListHandler(s32 operation, struct menuitem *it s32 numtracks = mpGetNumUnlockedTracks(); if (data->list.value < numtracks) { - return (s32) mpGetTrackName(data->list.value); + return (uintptr_t) mpGetTrackName(data->list.value); } if (mpGetUsingMultipleTunes()) { - return (s32) langGet(var80085ce8[1 + data->list.value - numtracks]); + return (uintptr_t) langGet(var80085ce8[1 + data->list.value - numtracks]); } - return (s32) langGet(var80085ce8[data->list.value - numtracks]); + return (uintptr_t) langGet(var80085ce8[data->list.value - numtracks]); } case MENUOP_SET: { @@ -4628,7 +4628,7 @@ MenuItemHandlerResult mpChallengesListMenuHandler(s32 operation, struct menuitem marginleft += 13; } - return (s32)gdl; + return (uintptr_t)gdl; case MENUOP_GETOPTIONHEIGHT: data->list.value = 26; break; @@ -4763,15 +4763,15 @@ MenuItemHandlerResult menuhandlerMpLock(s32 operation, struct menuitem *item, un break; case MENUOP_GETOPTIONTEXT: if (mpGetLockType() == MPLOCKTYPE_CHALLENGE) { - return (s32) langGet(L_MPMENU_049); // "Challenge" + return (uintptr_t) langGet(L_MPMENU_049); // "Challenge" } if (data->dropdown.value <= 3) { - return (s32) langGet(labels[data->dropdown.value]); + return (uintptr_t) langGet(labels[data->dropdown.value]); } if (mpGetLockType() == MPLOCKTYPE_PLAYER) { - return (s32) g_PlayerConfigsArray[mpGetLockPlayerNum()].base.name; + return (uintptr_t) g_PlayerConfigsArray[mpGetLockPlayerNum()].base.name; } - return (s32) mpGetCurrentPlayerName(item); + return (uintptr_t) mpGetCurrentPlayerName(item); case MENUOP_SET: if (mpGetLockType() != MPLOCKTYPE_CHALLENGE) { mpSetLock(data->dropdown.value, g_MpPlayerNum); @@ -5031,7 +5031,7 @@ MenuItemHandlerResult menuhandlerPlayerTeam(s32 operation, struct menuitem *item #endif break; case MENUOP_GETOPTIONTEXT: - return (s32) &g_BossFile.teamnames[data->dropdown.value]; + return (uintptr_t) &g_BossFile.teamnames[data->dropdown.value]; case MENUOP_SET: g_Vars.mpplayerteams[item->param] = data->dropdown.value; break; @@ -5061,7 +5061,7 @@ MenuItemHandlerResult menuhandlerMpNumberOfSimulants(s32 operation, struct menui break; case MENUOP_GETOPTIONTEXT: sprintf(g_StringPointer, "%d\n", data->dropdown.value + 1); - return (s32) g_StringPointer; + return (uintptr_t) g_StringPointer; case MENUOP_SET: g_Vars.mpquickteamnumsims = data->dropdown.value + 1; break; @@ -5087,7 +5087,7 @@ MenuItemHandlerResult menuhandlerMpSimulantsPerTeam(s32 operation, struct menuit break; case MENUOP_GETOPTIONTEXT: sprintf(g_StringPointer, "%d\n", data->dropdown.value + 1); - return (s32) g_StringPointer; + return (uintptr_t) g_StringPointer; case MENUOP_SET: g_Vars.unk0004a0 = data->dropdown.value + 1; break; @@ -5123,7 +5123,7 @@ MenuItemHandlerResult mpQuickTeamSimulantDifficultyHandler(s32 operation, struct for (i = 0; i < NUM_BOTDIFFS; i++) { if (challengeIsFeatureUnlocked(g_BotProfiles[i].requirefeature)) { if (count == data->dropdown.value) { - return (s32) langGet(i + L_MISC_082); + return (uintptr_t) langGet(i + L_MISC_082); } count++; diff --git a/src/game/objectives.c b/src/game/objectives.c index 01f38e962..9d079af7e 100644 --- a/src/game/objectives.c +++ b/src/game/objectives.c @@ -91,7 +91,7 @@ void tagsReset(void) g_NumTags = index; if (g_NumTags) { - u32 size = index * 4; + u32 size = index * sizeof(uintptr_t); g_TagPtrs = mempAlloc(ALIGN16(size), MEMPOOL_STAGE); for (index = 0; index < g_NumTags; index++) { diff --git a/src/game/player.c b/src/game/player.c index ddb73c726..198254e16 100644 --- a/src/game/player.c +++ b/src/game/player.c @@ -1454,6 +1454,10 @@ void playerTickChrBody(void) model->rwdatalen = 256; +#ifdef PLATFORM_64BIT + model->rwdatalen += 128; +#endif + texGetPoolLeftPos(&texpool); // @TODO: Figure out these arguments diff --git a/src/game/playerreset.c b/src/game/playerreset.c index 896601929..346dedc97 100644 --- a/src/game/playerreset.c +++ b/src/game/playerreset.c @@ -236,7 +236,7 @@ void playerReset(void) cmd = (struct cmd32 *)((uintptr_t)cmd + 12); break; case INTROCMD_CREDITOFFSET: - thing = (struct gecreditsdata *)((s32)g_GeCreditsData + cmd->param1); + thing = (struct gecreditsdata *)((uintptr_t)g_GeCreditsData + cmd->param1); g_CurrentGeCreditsData = thing; while (thing->text1 || thing->text2) { thing++; @@ -431,6 +431,11 @@ void playerReset(void) g_Vars.currentplayer->bond2.unk00.y = 0; g_Vars.currentplayer->bond2.unk00.z = cosf(turnanglerad); + // #TEMP + g_Vars.currentplayer->prop->pos.f[0] = -1101.97473; + g_Vars.currentplayer->prop->pos.f[1] = 481.576385; + g_Vars.currentplayer->prop->pos.f[2] = 283.67334; + g_Vars.currentplayer->prop->pos.f[0] = g_Vars.currentplayer->bondprevpos.f[0] = pos.f[0]; g_Vars.currentplayer->prop->pos.f[1] = g_Vars.currentplayer->bondprevpos.f[1] = pos.f[1]; g_Vars.currentplayer->prop->pos.f[2] = g_Vars.currentplayer->bondprevpos.f[2] = pos.f[2]; diff --git a/src/game/propobj.c b/src/game/propobj.c index 99c405475..2d36736c0 100644 --- a/src/game/propobj.c +++ b/src/game/propobj.c @@ -15041,13 +15041,13 @@ bool func0f0849dc(struct model *model, struct modelnode *nodearg, struct coord * if (rwdata->gdl != NULL) { if (rwdata->gdl == rodata->opagdl) { - s3 = (Gfx *)((uintptr_t)rodata->colours + ((u32)UNSEGADDR(rodata->opagdl) & 0xffffff)); + s3 = (Gfx *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->opagdl) & 0xffffff)); } else { s3 = rwdata->gdl; } if (rodata->xlugdl != NULL) { - s5 = (void *)((uintptr_t)rodata->colours + ((u32)UNSEGADDR(rodata->xlugdl) & 0xffffff)); + s5 = (void *)((uintptr_t)rodata->colours + ((uintptr_t)UNSEGADDR(rodata->xlugdl) & 0xffffff)); } vertices = rwdata->vertices; @@ -15059,10 +15059,10 @@ bool func0f0849dc(struct model *model, struct modelnode *nodearg, struct coord * struct modelrodata_gundl *rodata = &node->rodata->gundl; if (rodata->opagdl != NULL) { - s3 = (Gfx *)((uintptr_t)rodata->baseaddr + ((u32)UNSEGADDR(rodata->opagdl) & 0xffffff)); + s3 = (Gfx *)((uintptr_t)rodata->baseaddr + ((uintptr_t)UNSEGADDR(rodata->opagdl) & 0xffffff)); if (rodata->xlugdl != NULL) { - s5 = (Gfx *)((uintptr_t)rodata->baseaddr + ((u32)UNSEGADDR(rodata->xlugdl) & 0xffffff)); + s5 = (Gfx *)((uintptr_t)rodata->baseaddr + ((uintptr_t)UNSEGADDR(rodata->xlugdl) & 0xffffff)); } vertices = (void *)(uintptr_t)rodata->baseaddr; diff --git a/src/game/stars.c b/src/game/stars.c index 3f15c28a5..e787fb1c5 100644 --- a/src/game/stars.c +++ b/src/game/stars.c @@ -142,7 +142,7 @@ void starsReset(void) } count = 6 * g_StarGridSize * g_StarGridSize + 1; - g_StarData3 = (f32 *)(count * sizeof(f32) + (s32)g_StarPosIndexes); + g_StarData3 = (f32 *)(count * sizeof(f32) + (uintptr_t)g_StarPosIndexes); stars0f135c70(); diff --git a/src/game/texdecompress.c b/src/game/texdecompress.c index 71d7b961d..7a71781f7 100644 --- a/src/game/texdecompress.c +++ b/src/game/texdecompress.c @@ -2097,7 +2097,7 @@ void texInitPool(struct texpool *pool, u8 *start, s32 len) pool->start = start; pool->end = (struct tex *)(start + len); pool->leftpos = start; - pool->rightpos = (struct tex *)((s32)start + len); + pool->rightpos = (struct tex *)((uintptr_t)start + len); } struct tex *texFindInPool(s32 texturenum, struct texpool *pool) @@ -2144,7 +2144,7 @@ struct tex *texFindInPool(s32 texturenum, struct texpool *pool) s32 texGetPoolFreeBytes(struct texpool *pool) { - return (s32) pool->rightpos - (s32) pool->leftpos; + return (uintptr_t) pool->rightpos - (uintptr_t) pool->leftpos; } u8 *texGetPoolLeftPos(struct texpool *pool) diff --git a/src/game/trainingmenus.c b/src/game/trainingmenus.c index 430d0db6b..495009312 100644 --- a/src/game/trainingmenus.c +++ b/src/game/trainingmenus.c @@ -209,7 +209,7 @@ MenuItemHandlerResult frWeaponListMenuHandler(s32 operation, struct menuitem *it G_TX_RENDERTILE, 0, 0x0160, 1024 / g_ScaleX, -1024); } - return (s32)gdl; + return (uintptr_t)gdl; } return 0; @@ -279,7 +279,7 @@ MenuItemHandlerResult frDifficultyDropdownMenuHandler(s32 operation, struct menu } break; case MENUOP_GETOPTIONTEXT: - return (s32) langGet(names[data->dropdown.value]); + return (uintptr_t) langGet(names[data->dropdown.value]); case MENUOP_SET: frSetDifficulty(data->dropdown.value); menuPushDialog(&g_FrTrainingInfoPreGameMenuDialog); @@ -876,7 +876,7 @@ MenuItemHandlerResult frScoringMenuHandler(s32 operation, struct menuitem *item, gdl = menugfxDrawDialogBorderLine(gdl, renderdata->x + 90, renderdata->y + 50, renderdata->x + 96, renderdata->y + 51, linecolourmid, linecolourfig); #endif - return (s32)gdl; + return (uintptr_t)gdl; } return 0; @@ -1438,10 +1438,10 @@ MenuItemHandlerResult ciOfficeInformationMenuHandler(s32 operation, struct menui case MENUOP_GETOPTIONTEXT: if (data->list.value < numunlockedchrbios) { chrbio = ciGetChrBioByBodynum(ciGetChrBioBodynumBySlot(data->list.value)); - return (s32) langGet(chrbio->name); + return (uintptr_t) langGet(chrbio->name); } else { miscbio = ciGetMiscBio(ciGetMiscBioIndexBySlot(data->list.value - numunlockedchrbios)); - return (s32) langGet(miscbio->name); + return (uintptr_t) langGet(miscbio->name); } break; case MENUOP_SET: @@ -1459,7 +1459,7 @@ MenuItemHandlerResult ciOfficeInformationMenuHandler(s32 operation, struct menui data->list.value = 2; break; case MENUOP_GETOPTGROUPTEXT: - return (s32) langGet(groups[data->list.value].name); + return (uintptr_t) langGet(groups[data->list.value].name); case MENUOP_GETGROUPSTARTINDEX: data->list.groupstartindex = data->list.value == 0 ? 0 : numunlockedchrbios; break; @@ -1693,7 +1693,7 @@ MenuItemHandlerResult dtDeviceListMenuHandler(s32 operation, struct menuitem *it data->list.value = dtGetNumAvailable(); break; case MENUOP_GETOPTIONTEXT: - return (s32) bgunGetName(dtGetWeaponByDeviceIndex(dtGetIndexBySlot(data->list.value))); + return (uintptr_t) bgunGetName(dtGetWeaponByDeviceIndex(dtGetIndexBySlot(data->list.value))); case MENUOP_SET: g_DtSlot = data->list.value; menuPushDialog(&g_DtDetailsMenuDialog); @@ -2006,7 +2006,7 @@ MenuItemHandlerResult htHoloListMenuHandler(s32 operation, struct menuitem *item data->list.value = htGetNumUnlocked(); break; case MENUOP_GETOPTIONTEXT: - return (s32) htGetName(htGetIndexBySlot(data->list.value)); + return (uintptr_t) htGetName(htGetIndexBySlot(data->list.value)); case MENUOP_SET: var80088bb4 = data->list.value; menuPushDialog(&g_HtDetailsMenuDialog); @@ -2512,7 +2512,7 @@ MenuItemHandlerResult ciHangarInformationMenuHandler(s32 operation, struct menui break; case MENUOP_GETOPTIONTEXT: bio = ciGetHangarBio(ciGetHangarBioIndexBySlot(data->list.value)); - return (s32) langGet(bio->name); + return (uintptr_t) langGet(bio->name); case MENUOP_SET: g_HangarBioSlot = data->list.value; bioindex = ciGetHangarBioIndexBySlot(g_HangarBioSlot); @@ -2530,7 +2530,7 @@ MenuItemHandlerResult ciHangarInformationMenuHandler(s32 operation, struct menui data->list.value = 2; break; case MENUOP_GETOPTGROUPTEXT: - return (s32) langGet(groups[data->list.value].name); + return (uintptr_t) langGet(groups[data->list.value].name); case MENUOP_GETGROUPSTARTINDEX: data->list.groupstartindex = data->list.value == 0 ? 0 : groups[1].offset; break; @@ -2612,7 +2612,7 @@ MenuItemHandlerResult ciHangarTitleMenuHandler(s32 operation, struct menuitem *i gdl = text0f153780(gdl); - return (s32)gdl; + return (uintptr_t)gdl; } return 0; diff --git a/src/include/types.h b/src/include/types.h index 88812911c..3a5059392 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -27,7 +27,7 @@ typedef s32 PakErr1; typedef s32 PakErr2; typedef s32 MenuDialogHandlerResult; -typedef intptr_t MenuItemHandlerResult; +typedef uintptr_t MenuItemHandlerResult; typedef s16 RoomNum; #ifdef PLATFORM_N64 @@ -3427,7 +3427,7 @@ struct menuitem { intptr_t param3; union { - s32 (*handler)(s32 operation, struct menuitem *item, union handlerdata *data); + uintptr_t (*handler)(s32 operation, struct menuitem *item, union handlerdata *data); void (*handlervoid)(s32 operation, struct menuitem *item, union handlerdata *data); }; }; @@ -3877,7 +3877,11 @@ struct menumodel { /*0x05e*/ s16 curanimnum; /*0x060*/ struct model bodymodel; /*0x084*/ struct anim bodyanim; +#ifdef PLATFORM_64BIT + /*0x110*/ u32 rwdata[256+128]; +#else /*0x110*/ u32 rwdata[256]; +#endif /*0x510*/ f32 curposx; /*0x514*/ f32 curposy; /*0x518*/ f32 curposz; diff --git a/src/lib/main.c b/src/lib/main.c index c03da5235..01c4d805d 100644 --- a/src/lib/main.c +++ b/src/lib/main.c @@ -978,7 +978,7 @@ void mainLoop(void) { char message[80]; u32 stack2; - sprintf(message, "boss.c default: %08x type %d\n", (s32) msg, *(s16 *) msg); + sprintf(message, "boss.c default: %08x type %d\n", (uintptr_t) msg, *(s16 *) msg); crashSetMessage(message); CRASH(); } From 00c990eded17e37b9a58d137406a8b40a1880498 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Tue, 23 Jul 2024 01:52:35 +0800 Subject: [PATCH 05/81] portx64: lots of adjustments in memory allocations/data sizes/offsets etc --- src/game/bg.c | 4 ++-- src/game/bondgun.c | 8 ++++++++ src/game/dlights.c | 12 ++++++++++++ src/game/gfxmemory.c | 4 ++++ src/game/modelmgr.c | 16 ++++++++------- src/game/modelmgrreset.c | 6 +++--- src/game/nbomb.c | 4 ++++ src/game/player.c | 6 ++++++ src/game/setuppads.c | 4 ++++ src/game/texdecompress.c | 7 ++++++- src/include/game/title.h | 2 +- src/lib/snd.c | 42 ++++++++++++++++++++++------------------ 12 files changed, 82 insertions(+), 33 deletions(-) diff --git a/src/game/bg.c b/src/game/bg.c index 6ca79a5de..ac6b51c7c 100644 --- a/src/game/bg.c +++ b/src/game/bg.c @@ -763,7 +763,7 @@ Gfx *bgRenderGdlInXray(Gfx *gdl, s8 *readgdl, Vtx *vertices, s16 arg3[3]) gdl = bgProcessXrayTri(gdl, &xraydata, dmemvertices[x], dmemvertices[y], dmemvertices[z], dmemcolours[x], dmemcolours[y], dmemcolours[z], inrange[x], inrange[y], inrange[z]); } - readgdl += 8; + readgdl += sizeof(Gfx); } gdl = bgRenderXrayData(gdl, &xraydata); @@ -1606,7 +1606,7 @@ void bgReset(s32 stagenum) var800a4920 = *(u32 *)g_BgPrimaryData; if (var800a4920 == 0) { - g_BgPrimaryData2 = (u32 *)g_BgPrimaryData; + g_BgPrimaryData2 = (uintptr_t*)g_BgPrimaryData; g_BgRooms = (struct bgroom *)(g_BgPrimaryData2[1] + g_BgPrimaryData - 0x0f000000); goto foo; foo:; g_Vars.roomcount = 0; diff --git a/src/game/bondgun.c b/src/game/bondgun.c index 1bfe79cc3..f78dc6d44 100644 --- a/src/game/bondgun.c +++ b/src/game/bondgun.c @@ -165,8 +165,13 @@ u32 fill2[1]; Lights1 var80070090 = gdSPDefLights1(0x96, 0x96, 0x96, 0xff, 0xff, 0xff, 0xb2, 0x4d, 0x2e); +#ifdef PLATFORM_64BIT +u32 g_BgunGunMemBaseSizeDefault = 150 * 1024 * 2; // #TODO adjust these values properly +u32 g_BgunGunMemBaseSize4Mb2P = 120 * 1024 * 2; +#else u32 g_BgunGunMemBaseSizeDefault = 150 * 1024; u32 g_BgunGunMemBaseSize4Mb2P = 120 * 1024; +#endif u16 g_CartFileNums[] = { FILE_GCARTRIDGE, @@ -3844,6 +3849,9 @@ void bgunTickGunLoad(void) // Reserve some space for textures allocsize = fileGetLoadedSize(player->gunctrl.loadfilenum) + 0xe00; +#ifdef PLATFORM_64BIT + allocsize += 0xe00; +#endif osSyncPrintf("BriGun: Used size %d (Ob Size %d)\n"); osSyncPrintf("BriGun: block len %d usedsize %d\n"); diff --git a/src/game/dlights.c b/src/game/dlights.c index 018f3e4e4..2dd9af0fe 100644 --- a/src/game/dlights.c +++ b/src/game/dlights.c @@ -592,7 +592,11 @@ void func0f001c0c(void) table2size = align16(g_NumPortals * 4); table3size = align16(g_Vars.roomcount * 4); table4size = align16((u32)var8009cae0 * (u32)var8009cae0); +#ifdef PLATFORM_64BIT + sp68 = align16(g_Vars.roomcount * 8 * 2); +#else sp68 = align16(g_Vars.roomcount * 8); +#endif mempGetStageFree(); @@ -1695,11 +1699,19 @@ void func0f004c6c(void) u8 *ptr; u8 *backupptr; +#ifdef PLATFORM_64BIT + sp44 = align16(0x2000 * 2); + sp40 = align16(g_NumPortals * 4 * 2); + sp3c = align16(g_NumPortals * 0xc * 2); + sp38 = align16(g_NumPortals * 4 * 2); + sp34 = align16(g_NumPortals * 2 * 2); +#else sp44 = align16(0x2000); sp40 = align16(g_NumPortals * 4); sp3c = align16(g_NumPortals * 0xc); sp38 = align16(g_NumPortals * 4); sp34 = align16(g_NumPortals * 2); +#endif for (i = 0, s4 = sp38; i < g_NumPortals; i++) { if (i != 0) { diff --git a/src/game/gfxmemory.c b/src/game/gfxmemory.c index a7d6bb9d6..f105bce2c 100644 --- a/src/game/gfxmemory.c +++ b/src/game/gfxmemory.c @@ -148,7 +148,11 @@ void *gfxAllocateMatrix(void) LookAt *gfxAllocateLookAt(s32 count) { void *ptr = g_GfxMemPos; +#ifdef PLATFORM_64BIT + g_GfxMemPos += count * (sizeof(LookAt) * 2); +#else g_GfxMemPos += count * (sizeof(LookAt) / 2); +#endif return ptr; } diff --git a/src/game/modelmgr.c b/src/game/modelmgr.c index d6bec4876..70fefead6 100644 --- a/src/game/modelmgr.c +++ b/src/game/modelmgr.c @@ -109,6 +109,10 @@ struct model *modelmgrInstantiateModel(struct modeldef *modeldef, bool withanim) struct model *model = NULL; u32 *rwdatas = NULL; s16 datalen = -1; + s16 extra = 0; +#ifdef PLATFORM_64BIT + extra = 128; +#endif s32 i; if (!g_ModelIsLvResetting) { @@ -148,7 +152,7 @@ struct model *modelmgrInstantiateModel(struct modeldef *modeldef, bool withanim) } else { // At this point, it's during gameplay. A model instance slot has // been found or allocated, but rwdata needs to be allocated. - if (modeldef->rwdatalen < 256) { + if (modeldef->rwdatalen < 256+extra) { bool done = false; u32 stack; @@ -181,7 +185,7 @@ struct model *modelmgrInstantiateModel(struct modeldef *modeldef, bool withanim) // 256 words (0x400 bytes) or less -> try type 3 // First looking for unused slots with an existing rwdata allocation - if (!done && modeldef->rwdatalen <= 256) { + if (!done && modeldef->rwdatalen <= 256+extra) { for (i = 0; i < NUMTYPE3(); i++) { if (g_ModelRwdataBindings[2][i].model == NULL && g_ModelRwdataBindings[2][i].rwdata != NULL) { osSyncPrintf("MotInst: Using cache entry type 3 %d (0x%08x) - Bytes=%d\n"); @@ -195,10 +199,10 @@ struct model *modelmgrInstantiateModel(struct modeldef *modeldef, bool withanim) } // Type 3 again, but looking for null rwdata allocations - if (!done && modeldef->rwdatalen <= 256) { + if (!done && modeldef->rwdatalen <= 256+extra) { for (i = 0; i < NUMTYPE3(); i++) { if (g_ModelRwdataBindings[2][i].model == NULL && g_ModelRwdataBindings[2][i].rwdata == NULL) { - g_ModelRwdataBindings[2][i].rwdata = mempAlloc(256 * 4, MEMPOOL_STAGE); + g_ModelRwdataBindings[2][i].rwdata = mempAlloc((256+128) * 4, MEMPOOL_STAGE); rwdatas = g_ModelRwdataBindings[2][i].rwdata; g_ModelRwdataBindings[2][i].model = model; break; @@ -215,9 +219,7 @@ struct model *modelmgrInstantiateModel(struct modeldef *modeldef, bool withanim) datalen = IS4MB() ? 52 : 256; } -#ifdef PLATFORM_64BIT - datalen += 128; -#endif + datalen += extra; if (datalen < modeldef->rwdatalen) { datalen = modeldef->rwdatalen; diff --git a/src/game/modelmgrreset.c b/src/game/modelmgrreset.c index 1d6600514..2f268e06e 100644 --- a/src/game/modelmgrreset.c +++ b/src/game/modelmgrreset.c @@ -101,17 +101,17 @@ void modelmgrAllocateSlots(s32 numobjs, s32 numchrs) if (NUMTYPE1()) { g_ModelRwdataBindings[0] = (struct modelrwdatabinding *) ptr; - ptr += NUMTYPE1() * 8; + ptr += NUMTYPE1() * sizeof(struct modelrwdatabinding); } if (NUMTYPE2()) { g_ModelRwdataBindings[1] = (struct modelrwdatabinding *) ptr; - ptr += NUMTYPE2() * 8; + ptr += NUMTYPE2() * sizeof(struct modelrwdatabinding); } if (NUMTYPE3()) { g_ModelRwdataBindings[2] = (struct modelrwdatabinding *) ptr; - ptr += NUMTYPE3() * 8; + ptr += NUMTYPE3() * sizeof(struct modelrwdatabinding); } g_ModelSlots = (struct model *) ptr; diff --git a/src/game/nbomb.c b/src/game/nbomb.c index b5f4fa72b..e3e3dcb9d 100644 --- a/src/game/nbomb.c +++ b/src/game/nbomb.c @@ -314,7 +314,11 @@ s32 nbombCalculateAlpha(struct nbomb *nbomb) Gfx *nbombCreateGdl(void) { Vtx *vertices; +#ifdef PLATFORM_64BIT + u32 gdlsizes[] = { 0x0a30*2, 0x0330*2 }; // 1 player, 2+ players +#else u32 gdlsizes[] = { 0x0a30, 0x0330 }; // 1 player, 2+ players +#endif Gfx *gdlstart; Gfx *gdl; s32 index = 0; diff --git a/src/game/player.c b/src/game/player.c index 198254e16..2b3b418c3 100644 --- a/src/game/player.c +++ b/src/game/player.c @@ -1414,6 +1414,9 @@ void playerTickChrBody(void) rwdatas = (u32 *)(allocation + offset1); osSyncPrintf("Gunmem: savedata 0x%08x\n", (uintptr_t)rwdatas); offset1 += 0x400; +#ifdef PLATFORM_64BIT + offset1 += 0x200; +#endif offset1 = ALIGN64(offset1); weaponobj = (struct weaponobj *)(allocation + offset1); @@ -1432,6 +1435,9 @@ void playerTickChrBody(void) } offset2 += 0x4000; +#ifdef PLATFORM_64BIT + offset2 += 0x2000; +#endif bgunCalculateGunMemCapacity(); spe8 = g_Vars.currentplayer->gunmem2 + offset2; texInitPool(&texpool, spe8, bgunCalculateGunMemCapacity() - offset2); diff --git a/src/game/setuppads.c b/src/game/setuppads.c index 9e629fdad..241d31479 100644 --- a/src/game/setuppads.c +++ b/src/game/setuppads.c @@ -40,7 +40,11 @@ void setupPreparePads(void) s32 offset; g_PadsFile = (struct padsfileheader *)g_StageSetup.padfiledata; +#ifdef PLATFORM_64BIT + g_PadOffsets = (u16 *)(g_StageSetup.padfiledata + 0x20); +#else g_PadOffsets = (u16 *)(g_StageSetup.padfiledata + 0x14); +#endif padnum = 0; numpads = g_PadsFile->numpads; diff --git a/src/game/texdecompress.c b/src/game/texdecompress.c index 7a71781f7..494bda391 100644 --- a/src/game/texdecompress.c +++ b/src/game/texdecompress.c @@ -2155,11 +2155,16 @@ u8 *texGetPoolLeftPos(struct texpool *pool) void texLoadFromDisplayList(Gfx *gdl, struct texpool *pool, s32 arg2) { u8 *bytes = (u8 *)gdl; + u8 ofs = 4; +#ifdef PLATFORM_64BIT + ofs = 8; +#endif + while (bytes[GFX_W0_BYTE(0)] != (u8)G_ENDDL) { // Look for GBI sequence: fd...... abcd.... if (bytes[GFX_W0_BYTE(0)] == G_SETTIMG && bytes[GFX_W1_BYTE(0)] == 0xab && bytes[GFX_W1_BYTE(1)] == 0xcd) { - texLoad((texnum_t *)((uintptr_t)bytes + 4), pool, arg2); + texLoad((texnum_t *)((uintptr_t)bytes + ofs), pool, arg2); } bytes += sizeof(Gfx); diff --git a/src/include/game/title.h b/src/include/game/title.h index 02ecfb690..3e6771dc5 100644 --- a/src/include/game/title.h +++ b/src/include/game/title.h @@ -4,7 +4,7 @@ #include "data.h" #include "types.h" -#define TITLE_ALLOCSIZE 1024 * 332 +#define TITLE_ALLOCSIZE 1024 * 378 extern u32 var800624d4; extern u32 var800624d8; diff --git a/src/lib/snd.c b/src/lib/snd.c index 997f868b5..0abedf5a8 100644 --- a/src/lib/snd.c +++ b/src/lib/snd.c @@ -64,7 +64,7 @@ struct curmp3 { }; s32 g_NumSounds; -u32 *g_ALSoundRomOffsets; +uintptr_t *g_ALSoundRomOffsets; s32 g_SndMaxFxBusses; u32 var80094eac; struct curmp3 g_SndCurMp3; @@ -984,12 +984,12 @@ void sndLoadSfxCtl(void) // Calculate the size of the ALInstrument and load it. The pointer is then // shifted forward to point to the instrument's ALSound array. This leaks // some memory but this is initialisation code so it's not much of an issue. - size = g_NumSounds * 4 + 20; + size = g_NumSounds * sizeof(uintptr_t) + 20; size = ALIGN16(size); g_ALSoundRomOffsets = alHeapAlloc(&g_SndHeap, 1, size); dmaExec(g_ALSoundRomOffsets, romaddr, size); - *(u32 *)&g_ALSoundRomOffsets += 0x10; + *(uintptr_t *)&g_ALSoundRomOffsets += 0x10; // Convert ctl-local offsets to ROM offsets for (i = 0; i < g_NumSounds; i++) { @@ -1030,8 +1030,8 @@ void sndIncrementAges(void) ALEnvelope *sndLoadEnvelope(u32 offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 - u8 spaf[0x50]; - u8 sp5f[0x50]; + u8 spaf[0x90]; + u8 sp5f[0x90]; ALEnvelope *s2 = (ALEnvelope *)ALIGN16((uintptr_t)spaf); ALEnvelope *s1 = (ALEnvelope *)ALIGN16((uintptr_t)sp5f); s32 i; @@ -1041,14 +1041,14 @@ ALEnvelope *sndLoadEnvelope(u32 offset, u16 cacheindex) offset += (romptr_t) REF_SEG _sfxctlSegmentRomStart; do { - dmaExecHighPriority(s2, offset, 0x40); + dmaExecHighPriority(s2, offset, 16 * sizeof(uintptr_t)); sum1 = 0; for (i = 0; i < 16U; i++) { sum1 += ((u32 *)s2)[i]; } - dmaExecHighPriority(s1, offset, 0x40); + dmaExecHighPriority(s1, offset, 16 * sizeof(uintptr_t)); sum2 = 0; for (i = 0; i < 16U; i++) { @@ -1077,8 +1077,8 @@ ALEnvelope *sndLoadEnvelope(u32 offset, u16 cacheindex) ALKeyMap *sndLoadKeymap(u32 offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 - u8 spaf[0x50]; - u8 sp5f[0x50]; + u8 spaf[0x90]; + u8 sp5f[0x90]; ALKeyMap *s2 = (ALKeyMap *)ALIGN16((uintptr_t)spaf); ALKeyMap *s1 = (ALKeyMap *)ALIGN16((uintptr_t)sp5f); s32 i; @@ -1088,14 +1088,14 @@ ALKeyMap *sndLoadKeymap(u32 offset, u16 cacheindex) offset += (romptr_t) REF_SEG _sfxctlSegmentRomStart; do { - dmaExecHighPriority(s2, offset, 0x40); + dmaExecHighPriority(s2, offset, 16 * sizeof(uintptr_t)); sum1 = 0; for (i = 0; i < 16U; i++) { sum1 += ((u32 *)s2)[i]; } - dmaExecHighPriority(s1, offset, 0x40); + dmaExecHighPriority(s1, offset, 16 * sizeof(uintptr_t)); sum2 = 0; for (i = 0; i < 16U; i++) { @@ -1171,8 +1171,8 @@ ALADPCMBook *sndLoadAdpcmBook(u32 offset, u16 cacheindex) ALADPCMloop *sndLoadAdpcmLoop(u32 offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 - u8 spaf[0x50]; - u8 sp5f[0x50]; + u8 spaf[0x90]; + u8 sp5f[0x90]; ALADPCMloop *s2 = (ALADPCMloop *)ALIGN16((uintptr_t)spaf); ALADPCMloop *s1 = (ALADPCMloop *)ALIGN16((uintptr_t)sp5f); s32 i; @@ -1186,14 +1186,14 @@ ALADPCMloop *sndLoadAdpcmLoop(u32 offset, u16 cacheindex) offset += (romptr_t) REF_SEG _sfxctlSegmentRomStart; do { - dmaExecHighPriority(s2, offset, 0x40); + dmaExecHighPriority(s2, offset, 16 * sizeof(uintptr_t)); sum1 = 0; for (i = 0; i < 16U; i++) { sum1 += ((u32 *)s2)[i]; } - dmaExecHighPriority(s1, offset, 0x40); + dmaExecHighPriority(s1, offset, 16 * sizeof(uintptr_t)); sum2 = 0; for (i = 0; i < 16U; i++) { @@ -1226,8 +1226,8 @@ ALADPCMloop *sndLoadAdpcmLoop(u32 offset, u16 cacheindex) ALWaveTable *sndLoadWavetable(u32 offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 - u8 spaf[0x50]; - u8 sp5f[0x50]; + u8 spaf[0x90]; + u8 sp5f[0x90]; ALWaveTable *s2 = (ALWaveTable *)ALIGN16((uintptr_t)spaf); ALWaveTable *s1 = (ALWaveTable *)ALIGN16((uintptr_t)sp5f); s32 i; @@ -1238,14 +1238,14 @@ ALWaveTable *sndLoadWavetable(u32 offset, u16 cacheindex) offset += (romptr_t) REF_SEG _sfxctlSegmentRomStart; do { - dmaExecHighPriority(s2, offset, 0x40); + dmaExecHighPriority(s2, offset, 16 * sizeof(uintptr_t)); sum1 = 0; for (i = 0; i < 16U; i++) { sum1 += ((u32 *)s2)[i]; } - dmaExecHighPriority(s1, offset, 0x40); + dmaExecHighPriority(s1, offset, 16 * sizeof(uintptr_t)); sum2 = 0; for (i = 0; i < 16U; i++) { @@ -1457,6 +1457,10 @@ void sndInit(void) u32 heaplen = 1024 * 438; #endif +#ifdef PLATFORM_64BIT + heaplen = 1024 * 661; +#endif + g_Vars.langfilteron = false; if (IS4MB()) { From 315a5642da5aa6f30a478e059a2f40b2d0c7f60e Mon Sep 17 00:00:00 2001 From: Raf <> Date: Tue, 23 Jul 2024 01:58:47 +0800 Subject: [PATCH 06/81] portx64: pd extract - font/anim/audio segments and tiles/pads files fixes --- port/pdextract/ext_anims.c | 13 +++++++------ port/pdextract/ext_audio.c | 4 ++-- port/pdextract/ext_file_pads.c | 8 +------- port/pdextract/ext_file_tiles.c | 6 +++--- port/pdextract/ext_fonts.c | 2 +- port/pdextract/ext_jpnfonts.c | 2 +- 6 files changed, 15 insertions(+), 20 deletions(-) diff --git a/port/pdextract/ext_anims.c b/port/pdextract/ext_anims.c index 09d413200..e833d472d 100644 --- a/port/pdextract/ext_anims.c +++ b/port/pdextract/ext_anims.c @@ -22,10 +22,10 @@ static void extract_anims_data(uint32_t romoffset, size_t len) fclose(fp); } -static void extract_anims_table(uint32_t romoffset) +static void extract_anims_table(uint32_t data_offset, uint32_t table_offset) { - int num_anims = srctoh32(*(uint32_t *) &g_Rom[romoffset]); - struct animtableentry *srcanims = (struct animtableentry *) &g_Rom[romoffset + 4]; + int num_anims = srctoh32(*(uint32_t *) &g_Rom[table_offset]); + struct animtableentry *srcanims = (struct animtableentry *) &g_Rom[table_offset + 4]; size_t dstlen = ALIGN16(4 + num_anims * sizeof(struct animtableentry)); uint8_t *dst = calloc(1, dstlen); @@ -42,9 +42,11 @@ static void extract_anims_table(uint32_t romoffset) } char outfilename[1024]; - sprintf(outfilename, "%s/anims_table.bin", g_OutPath); + sprintf(outfilename, "%s/segs/animations", g_OutPath); FILE *fp = openfile(outfilename); + size_t datalen = table_offset - data_offset; + fwrite(&g_Rom[data_offset], datalen, 1, fp); fwrite(dst, dstlen, 1, fp); fclose(fp); @@ -72,6 +74,5 @@ void extract_anims(void) break; } - extract_anims_data(data_offset, table_offset - data_offset); - extract_anims_table(table_offset); + extract_anims_table(data_offset, table_offset); } diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c index 8a6278e4f..15ffd43d4 100644 --- a/port/pdextract/ext_audio.c +++ b/port/pdextract/ext_audio.c @@ -421,7 +421,7 @@ static void extract_audio_ctl(const char *filename, uint32_t romoffset, size_t s dstpos = convert_audio_bankfile(dst, dstpos, src, 0); char outfilename[1024]; - sprintf(outfilename, "%s/%s.ctl", g_OutPath, filename); + sprintf(outfilename, "%s/segs/%sctl", g_OutPath, filename); FILE *fp = openfile(outfilename); fwrite(dst, ALIGN16(dstpos), 1, fp); @@ -433,7 +433,7 @@ static void extract_audio_ctl(const char *filename, uint32_t romoffset, size_t s static void extract_audio_tbl(const char *filename, uint32_t romoffset, size_t len) { char outfilename[1024]; - sprintf(outfilename, "%s/%s.tbl", g_OutPath, filename); + sprintf(outfilename, "%s/segs/%stbl", g_OutPath, filename); FILE *fp = openfile(outfilename); fwrite(&g_Rom[romoffset], len, 1, fp); diff --git a/port/pdextract/ext_file_pads.c b/port/pdextract/ext_file_pads.c index bfb77cc1f..db642dc22 100644 --- a/port/pdextract/ext_file_pads.c +++ b/port/pdextract/ext_file_pads.c @@ -87,13 +87,7 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int struct padheader *host_padheader = (struct padheader *) &dst[dstpos]; uint32_t flags = (n64_padheader >> 14) & 0x3ffff; -#ifdef FORCE_BE32 - *(uint32_t *) host_padheader = htodst32(n64_padheader); -#else - host_padheader->flags = flags; - host_padheader->room = (n64_padheader >> 4) & 0x3ff; - host_padheader->liftnum = n64_padheader & 0xf; -#endif + *(uint32_t*)host_padheader = htodst32(n64_padheader); srcpos += sizeof(struct padheader); dstpos += sizeof(struct padheader); diff --git a/port/pdextract/ext_file_tiles.c b/port/pdextract/ext_file_tiles.c index f074aa731..772bccb5c 100644 --- a/port/pdextract/ext_file_tiles.c +++ b/port/pdextract/ext_file_tiles.c @@ -33,7 +33,7 @@ void extract_file_tiles(char *filename, uint32_t romoffset, size_t len) int num_rooms = srctoh32(*(uint32_t *) src); size_t src_ptr_table_len = (num_rooms + 1) * 4; - size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(uintptr_t); + size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(uint32_t); uint32_t *src_offsets = (uint32_t *) &src[4]; @@ -43,8 +43,8 @@ void extract_file_tiles(char *filename, uint32_t romoffset, size_t len) *(uint32_t *) dst = htodst32(num_rooms); - uintptr_t *dst_offsets = (uintptr_t *) (dst + ALIGN(4, sizeof(uintptr_t))); - uint32_t cur_dst_offset = ALIGN(4, sizeof(uintptr_t)) + dst_ptr_table_len; + uint32_t*dst_offsets = (uint32_t*) (dst + sizeof(uint32_t)); + uint32_t cur_dst_offset = dst_ptr_table_len + sizeof(uint32_t); uint32_t cur_src_offset = srctoh32(src_offsets[0]); uint32_t end_src_offset = srctoh32(src_offsets[num_rooms]); diff --git a/port/pdextract/ext_fonts.c b/port/pdextract/ext_fonts.c index 3ff07b494..c7a9bd7c0 100644 --- a/port/pdextract/ext_fonts.c +++ b/port/pdextract/ext_fonts.c @@ -102,7 +102,7 @@ static void extract_font(const char *filename, uint32_t romoffset, size_t srclen // Write it char outfilename[1024]; - sprintf(outfilename, "%s/fonts/%s.bin", g_OutPath, filename); + sprintf(outfilename, "%s/segs/font%s", g_OutPath, filename); FILE *fp = openfile(outfilename); fwrite(dst, dst_offset, 1, fp); diff --git a/port/pdextract/ext_jpnfonts.c b/port/pdextract/ext_jpnfonts.c index ea68b0d70..02d04c67a 100644 --- a/port/pdextract/ext_jpnfonts.c +++ b/port/pdextract/ext_jpnfonts.c @@ -6,7 +6,7 @@ static void extract_jpnfont(const char *filename, uint32_t romoffset, size_t len) { char outfilename[1024]; - sprintf(outfilename, "%s/%s.bin", g_OutPath, filename); + sprintf(outfilename, "%s/segs/%s", g_OutPath, filename); FILE *fp = openfile(outfilename); fwrite(&g_Rom[romoffset], len, 1, fp); From 8a94af6a1c42e1be28f8c439fadc79f25ec908ca Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sat, 27 Jul 2024 15:09:44 +0800 Subject: [PATCH 07/81] portx64: and more s32 -> uintptr_t --- src/game/bg.c | 6 ++--- src/game/bondgun.c | 44 ++++++++++++++++---------------- src/game/file.c | 18 ++++++------- src/game/filemgr.c | 2 +- src/game/modeldef.c | 4 +-- src/game/setup.c | 14 +++++----- src/game/texdecompress.c | 4 +-- src/include/constants.h | 2 +- src/include/game/bondgun.h | 4 +-- src/include/game/filemgr.h | 2 +- src/include/game/texdecompress.h | 2 +- src/include/lib/mema.h | 14 +++++----- src/include/lib/mp3.h | 2 +- src/include/lib/snd.h | 10 ++++---- src/include/types.h | 10 ++++---- src/lib/mema.c | 32 +++++++++++------------ src/lib/mp3.c | 4 +-- src/lib/naudio/n_load.c | 2 +- src/lib/snd.c | 16 ++++++------ src/lib/ultra/audio/bnkf.c | 22 ++++++++-------- 20 files changed, 107 insertions(+), 107 deletions(-) diff --git a/src/game/bg.c b/src/game/bg.c index ac6b51c7c..71ff53d24 100644 --- a/src/game/bg.c +++ b/src/game/bg.c @@ -113,7 +113,7 @@ struct portalcamcacheitem *g_PortalCameraCache; struct bgsnake g_BgSnake; s32 g_StageIndex = 1; -u32 var8007fc04 = 0; +uintptr_t var8007fc04 = 0; u8 *var8007fc08 = NULL; #if VERSION < VERSION_NTSC_1_0 @@ -1468,7 +1468,7 @@ void bgReset(s32 stagenum) u32 section2compsize; u32 section2start; u32 section1compsize; - u32 scratch; + uintptr_t scratch; var8007fc0c = 8; @@ -3640,7 +3640,7 @@ bool bgTestHitOnObj(struct coord *arg0, struct coord *arg1, struct coord *arg2, Gfx *imggdl = NULL; s32 texturenum; f32 lowestsqdist = MAXFLOAT; - s32 offset; + uintptr_t offset; s32 numvertices; Gfx *tri4gdl; s32 count; diff --git a/src/game/bondgun.c b/src/game/bondgun.c index f78dc6d44..54e8989cf 100644 --- a/src/game/bondgun.c +++ b/src/game/bondgun.c @@ -3799,16 +3799,16 @@ void bgunTickGunLoad(void) { s32 i; s32 numthistick; - u32 remaining; + u64 remaining; s32 padding; - u32 allocsize; - u32 loadsize; + u64 allocsize; + u64 loadsize; uintptr_t ptr; struct player *player = g_Vars.currentplayer; struct modeldef *modeldef; struct fileinfo *fileinfo; struct fileinfo *gunfileinfo; - s32 newvalue; + uintptr_t newvalue; uintptr_t end; u32 stack; #if VERSION >= VERSION_NTSC_1_0 @@ -4095,8 +4095,8 @@ void bgunTickMasterLoad(void) player->gunctrl.gunloadstate = GUNLOADSTATE_MODEL; player->gunctrl.loadfilenum = handfilenum; player->gunctrl.loadtomodeldef = &player->gunctrl.handmodeldef; - player->gunctrl.loadmemptr = (u32 *) &player->gunctrl.handmemloadptr; - player->gunctrl.loadmemremaining = (u32 *) &player->gunctrl.handmemloadremaining; + player->gunctrl.loadmemptr = (uintptr_t *) &player->gunctrl.handmemloadptr; + player->gunctrl.loadmemremaining = (uintptr_t*) &player->gunctrl.handmemloadremaining; } bgunTickGunLoad(); @@ -4123,8 +4123,8 @@ void bgunTickMasterLoad(void) player->gunctrl.gunloadstate = GUNLOADSTATE_MODEL; player->gunctrl.loadfilenum = filenum; player->gunctrl.loadtomodeldef = &player->gunctrl.gunmodeldef; - player->gunctrl.loadmemptr = (u32 *) &player->gunctrl.memloadptr; - player->gunctrl.loadmemremaining = (u32 *) &player->gunctrl.memloadremaining; + player->gunctrl.loadmemptr = (uintptr_t*) &player->gunctrl.memloadptr; + player->gunctrl.loadmemremaining = (uintptr_t*) &player->gunctrl.memloadremaining; } bgunTickGunLoad(); @@ -4165,8 +4165,8 @@ void bgunTickMasterLoad(void) player->gunctrl.loadfilenum = filenum; player->gunctrl.gunloadstate = GUNLOADSTATE_MODEL; player->gunctrl.loadtomodeldef = &player->gunctrl.cartmodeldef; - player->gunctrl.loadmemptr = (u32 *) &player->gunctrl.memloadptr; - player->gunctrl.loadmemremaining = (u32 *) &player->gunctrl.memloadremaining; + player->gunctrl.loadmemptr = (uintptr_t *) &player->gunctrl.memloadptr; + player->gunctrl.loadmemremaining = (uintptr_t*) &player->gunctrl.memloadremaining; break; } @@ -4194,16 +4194,16 @@ void bgunTickMasterLoad(void) hand->unk0dcc = (s32 *) player->gunctrl.memloadptr; - value = bgunCreateModelCmdList(&hand->gunmodel, player->gunctrl.gunmodeldef->rootnode, (s32 *) player->gunctrl.memloadptr); + value = bgunCreateModelCmdList(&hand->gunmodel, player->gunctrl.gunmodeldef->rootnode, (uintptr_t *) player->gunctrl.memloadptr); sum += value; player->gunctrl.memloadptr += value; player->gunctrl.memloadremaining -= value; if (player->gunctrl.handmodeldef != 0) { - hand->unk0dd0 = (s32 *) player->gunctrl.memloadptr; + hand->unk0dd0 = (uintptr_t*) player->gunctrl.memloadptr; - value = bgunCreateModelCmdList(&hand->handmodel, player->gunctrl.handmodeldef->rootnode, (s32 *) player->gunctrl.memloadptr); + value = bgunCreateModelCmdList(&hand->handmodel, player->gunctrl.handmodeldef->rootnode, (uintptr_t*) player->gunctrl.memloadptr); sum += value; player->gunctrl.memloadptr += value; @@ -6423,7 +6423,7 @@ void bgunDisarm(struct prop *attackerprop) * * With this function stubbed, part of the CMP150 model does not render. */ -void bgunExecuteModelCmdList(s32 *ptr) +void bgunExecuteModelCmdList(uintptr_t *ptr) { union modelrwdata *rwdata; struct modelnode *node; @@ -6480,7 +6480,7 @@ void bgunExecuteModelCmdList(s32 *ptr) * iterate the command list to update part visibility rather than iterate the * full model tree. */ -s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 *ptr) +s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, uintptr_t *ptr) { s32 len = 0; struct modelnode *node = nodearg; @@ -6501,7 +6501,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * ptr[2] = (uintptr_t)node; ptr[3] = (uintptr_t)rodata->distance.target; ptr += 4; - len += 16; + len += 4 * sizeof(uintptr_t); break; case MODELNODETYPE_TOGGLE: rodata = node->rodata; @@ -6513,7 +6513,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * ptr[2] = (uintptr_t)node; ptr[3] = (uintptr_t)rodata->toggle.target; ptr += 4; - len += 16; + len += 4 * sizeof(uintptr_t); break; case MODELNODETYPE_HEADSPOT: rwdata = modelGetNodeRwData(model, node); @@ -6522,7 +6522,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * ptr[0] = 2; ptr[1] = (uintptr_t)rwdata; ptr += 2; - len += 8; + len += 2 * sizeof(uintptr_t); break; case MODELNODETYPE_0B: rwdata = modelGetNodeRwData(model, node); @@ -6530,7 +6530,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * ptr[0] = 3; ptr[1] = (uintptr_t)rwdata; ptr += 2; - len += 8; + len += 2 * sizeof(uintptr_t); break; case MODELNODETYPE_CHRGUNFIRE: rwdata = modelGetNodeRwData(model, node); @@ -6538,7 +6538,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * ptr[0] = 4; ptr[1] = (uintptr_t)rwdata; ptr += 2; - len += 8; + len += 2 * sizeof(uintptr_t); break; case MODELNODETYPE_DL: rodata = node->rodata; @@ -6552,7 +6552,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * ptr[3] = (uintptr_t)rwdata->dl.gdl; ptr[4] = (uintptr_t)rwdata->dl.colours; ptr += 5; - len += 20; + len += 5 * sizeof(uintptr_t); break; } @@ -6576,7 +6576,7 @@ s32 bgunCreateModelCmdList(struct model *model, struct modelnode *nodearg, s32 * } *ptr = 6; - len += 4; + len += sizeof(uintptr_t); return len; } diff --git a/src/game/file.c b/src/game/file.c index 6bad0b536..815e7612e 100644 --- a/src/game/file.c +++ b/src/game/file.c @@ -4114,7 +4114,7 @@ u32 g_FileTable[] = { (uintptr_t) &_filenamesSegmentRomStart, }; #else // PLATFORM_N64 -u32 g_FileTable[NUM_FILES + 1]; // TODO: this is only used to get the filenum, remove this +uintptr_t g_FileTable[NUM_FILES + 1]; // TODO: this is only used to get the filenum, remove this #endif // PLATFORM_N64 romptr_t fileGetRomAddress(s32 filenum) @@ -4126,7 +4126,7 @@ romptr_t fileGetRomAddress(s32 filenum) #endif } -u32 fileGetRomSizeByTableAddress(u32 *filetableaddr) +u32 fileGetRomSizeByTableAddress(uintptr_t *filetableaddr) { #ifdef PLATFORM_N64 u32 size; @@ -4146,10 +4146,10 @@ u32 fileGetRomSizeByTableAddress(u32 *filetableaddr) s32 fileGetRomSize(s32 filenum) { - return fileGetRomSizeByTableAddress((u32 *)&g_FileTable[filenum]); + return fileGetRomSizeByTableAddress((uintptr_t*)&g_FileTable[filenum]); } -u32 file0f166ea8(u32 *filetableaddr) +u32 file0f166ea8(uintptr_t *filetableaddr) { return 0; } @@ -4158,7 +4158,7 @@ void fileLoad(u8 *dst, u32 allocationlen, romptr_t *romaddrptr, struct fileinfo { #ifndef PLATFORM_N64 // load the file first - const s32 filenum = (u32 *)romaddrptr - g_FileTable; + const s32 filenum = (uintptr_t *)romaddrptr - g_FileTable; u32 romsize = 0; u8 *filedata = romdataFileLoad(filenum, &romsize); if (!filedata) { @@ -4176,7 +4176,7 @@ void fileLoad(u8 *dst, u32 allocationlen, romptr_t *romaddrptr, struct fileinfo dmaExec(dst, *romaddrptr, romsize); } else { // DMA the compressed data to scratch space then inflate - u8 *scratch = (dst + allocationlen) - ((romsize + 7) & 0xfffffff8); + u8 *scratch = (dst + allocationlen) - ((romsize + 7) & 0xfffffffffffffff8); if ((uintptr_t)scratch - (uintptr_t)dst < 8) { info->loadedsize = 0; @@ -4241,7 +4241,7 @@ void fileLoadPartToAddr(u16 filenum, void *memaddr, s32 offset, u32 len) { u32 stack[2]; - if (fileGetRomSizeByTableAddress((u32 *)&g_FileTable[filenum])) { + if (fileGetRomSizeByTableAddress((uintptr_t*)&g_FileTable[filenum])) { #ifdef PLATFORM_N64 dmaExec(memaddr, (romptr_t) g_FileTable[filenum] + offset, len); #else @@ -4317,7 +4317,7 @@ void *fileLoadToNew(s32 filenum, u32 method) ptr = mempAlloc(info->loadedsize, MEMPOOL_STAGE); info->allocsize = info->loadedsize; - fileLoad(ptr, info->loadedsize, (u32 *)&g_FileTable[filenum], info); + fileLoad(ptr, info->loadedsize, (uintptr_t*)&g_FileTable[filenum], info); if (method != FILELOADMETHOD_EXTRAMEM) { mempRealloc(ptr, info->loadedsize, MEMPOOL_STAGE); @@ -4343,7 +4343,7 @@ void *fileLoadToAddr(s32 filenum, s32 method, u8 *ptr, u32 size) if (method == FILELOADMETHOD_EXTRAMEM || method == FILELOADMETHOD_DEFAULT) { info->allocsize = size; - fileLoad(ptr, size, (u32 *)&g_FileTable[filenum], info); + fileLoad(ptr, size, (uintptr_t*)&g_FileTable[filenum], info); } else { while (1); } diff --git a/src/game/filemgr.c b/src/game/filemgr.c index 544c3b82d..ab0e15ef9 100644 --- a/src/game/filemgr.c +++ b/src/game/filemgr.c @@ -411,7 +411,7 @@ struct menudialogdef g_FilemgrErrorMenuDialog = { * For a file listing, iterate the devices until the one at optionindex is found. * Depending on operation, return the device name or index of the first file. */ -s32 filemgrGetDeviceNameOrStartIndex(s32 listnum, s32 operation, s32 optionindex) +uintptr_t filemgrGetDeviceNameOrStartIndex(s32 listnum, s32 operation, s32 optionindex) { u16 names[] = { L_OPTIONS_111, // "Game Pak" diff --git a/src/game/modeldef.c b/src/game/modeldef.c index 42f5d97a4..ccd473c69 100644 --- a/src/game/modeldef.c +++ b/src/game/modeldef.c @@ -137,7 +137,7 @@ void modeldef0f1a7560(struct modeldef *modeldef, u16 filenum, u32 arg2, struct m texCopyGdls((Gfx *)((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff)), (Gfx *)(v1 + (uintptr_t)modeldef), loadedsize - (uintptr_t)(((uintptr_t)modeldef + (UNSEGADDR(gdl) & 0xffffff)) - (uintptr_t)modeldef)); - texLoadFromConfigs(modeldef->texconfigs, modeldef->numtexconfigs, texpool, (uintptr_t)modeldef2 - arg2); + texLoadFromConfigs(modeldef->texconfigs, modeldef->numtexconfigs, texpool, (uintptr_t)modeldef2 - (uintptr_t)arg2); while (node) { prevnode = node; @@ -190,7 +190,7 @@ struct modeldef *modeldefLoad(u16 fileid, u8 *dst, s32 size, struct texpool *arg if (dst) { modeldef = fileLoadToAddr(fileid, FILELOADMETHOD_EXTRAMEM, dst, size); } else { - modeldef = fileLoadToNew(fileid, FILELOADMETHOD_EXTRAMEM); + modeldef = fileLoadToNew(fileid, FILELOADMETHOD_EXTRAMEM, FT_LANG); } modelPromoteTypeToPointer(modeldef); diff --git a/src/game/setup.c b/src/game/setup.c index ec9337667..627bf1420 100644 --- a/src/game/setup.c +++ b/src/game/setup.c @@ -1237,7 +1237,7 @@ void setupLoadBriefing(s32 stagenum, u8 *buffer, s32 bufferlen, struct briefing langLoadToAddr(briefing->langbank, langbuffer, langbufferlen); - start = (struct defaultobj *)((uintptr_t)setup + (u32)setup->props); + start = (struct defaultobj *)((uintptr_t)setup + (uintptr_t)setup->props); if (start != NULL) { struct defaultobj *obj; @@ -1323,10 +1323,10 @@ void setupLoadFiles(s32 stagenum) setup = (struct stagesetup *)g_GeCreditsData; langLoad(langGetLangBankIndexFromStagenum(stagenum)); - g_StageSetup.intro = (s32 *)((uintptr_t)setup + (u32)setup->intro); - g_StageSetup.props = (u32 *)((uintptr_t)setup + (u32)setup->props); - g_StageSetup.paths = (struct path *)((uintptr_t)setup + (u32)setup->paths); - g_StageSetup.ailists = (struct ailist *)((uintptr_t)setup + (u32)setup->ailists); + g_StageSetup.intro = (s32 *)((uintptr_t)setup + (uintptr_t)setup->intro); + g_StageSetup.props = (u32 *)((uintptr_t)setup + (uintptr_t)setup->props); + g_StageSetup.paths = (struct path *)((uintptr_t)setup + (uintptr_t)setup->paths); + g_StageSetup.ailists = (struct ailist *)((uintptr_t)setup + (uintptr_t)setup->ailists); g_LoadType = LOADTYPE_PADS; @@ -1339,7 +1339,7 @@ void setupLoadFiles(s32 stagenum) // Convert ailist pointers from file-local to proper pointers if (g_StageSetup.ailists) { for (i = 0; g_StageSetup.ailists[i].list != NULL; i++) { - g_StageSetup.ailists[i].list = (u8 *)((uintptr_t)setup + (u32)g_StageSetup.ailists[i].list); + g_StageSetup.ailists[i].list = (u8 *)((uintptr_t)setup + (uintptr_t)g_StageSetup.ailists[i].list); } } @@ -1383,7 +1383,7 @@ void setupLoadFiles(s32 stagenum) // and calculate the path lengths if (g_StageSetup.paths) { for (i = 0; g_StageSetup.paths[i].pads != NULL; i++) { - g_StageSetup.paths[i].pads = (s32 *)((uintptr_t)g_StageSetup.paths[i].pads + (u32)setup); + g_StageSetup.paths[i].pads = (s32 *)((uintptr_t)g_StageSetup.paths[i].pads + (uintptr_t)setup); for (j = 0; g_StageSetup.paths[i].pads[j] >= 0; j++); diff --git a/src/game/texdecompress.c b/src/game/texdecompress.c index 494bda391..1e39dc2f6 100644 --- a/src/game/texdecompress.c +++ b/src/game/texdecompress.c @@ -2381,12 +2381,12 @@ void texLoad(texnum_t *updateword, struct texpool *pool, bool unusedarg) } } -void texLoadFromConfigs(struct textureconfig *configs, s32 numconfigs, struct texpool *pool, s32 arg3) +void texLoadFromConfigs(struct textureconfig *configs, s32 numconfigs, struct texpool *pool, uintptr_t arg3) { s32 i; for (i = 0; i < numconfigs; i++) { - if ((s32)configs[i].texturenum < NUM_TEXTURES) { + if ((uintptr_t)configs[i].texturenum < NUM_TEXTURES) { texLoad(&configs[i].texturenum, pool, true); configs[i].unk0b = 1; } else { diff --git a/src/include/constants.h b/src/include/constants.h index 09152e169..9a7c25e5f 100644 --- a/src/include/constants.h +++ b/src/include/constants.h @@ -51,7 +51,7 @@ #define ALIGN2(val) (((val) | 1) ^ 0x1) #define ALIGN8(val) ((((val) + 0x7) | 0x7) ^ 0x7) #define ALIGN16(val) ((((val) + 0xf) | 0xf) ^ 0xf) -#define ALIGN64(val) (((((u32)(val)) + 0x3f) | 0x3f) ^ 0x3f) +#define ALIGN64(val) (((((uintptr_t)(val)) + 0x3f) | 0x3f) ^ 0x3f) #define ARRAYCOUNT(a) (s32)(sizeof(a) / sizeof(a[0])) #define CHRNAVSEED(chr) ((g_Vars.lvframe60 >> 9) * 128 + chr->chrnum * 8) #define CHRRACE(chr) (chr ? chr->race : RACE_HUMAN) diff --git a/src/include/game/bondgun.h b/src/include/game/bondgun.h index 5bc113d38..5a9887b41 100644 --- a/src/include/game/bondgun.h +++ b/src/include/game/bondgun.h @@ -118,8 +118,8 @@ bool bgun0f0a27c8(void); void bgunHandlePlayerDead(void); bool bgunIsMissionCritical(s32 weaponnum); void bgunDisarm(struct prop *attacker); -void bgunExecuteModelCmdList(s32 *arg0); -s32 bgunCreateModelCmdList(struct model *model, struct modelnode *node, s32 *ptr); +void bgunExecuteModelCmdList(uintptr_t *arg0); +s32 bgunCreateModelCmdList(struct model *model, struct modelnode *node, uintptr_t *ptr); void bgunStartDetonateAnimation(s32 playernum); void bgunUpdateGangsta(struct hand *hand, s32 handnum, struct coord *arg2, struct weaponfunc *funcdef, Mtxf *arg4, Mtxf *arg5); void bgunUpdateSmoke(struct hand *hand, s32 handnum, s32 weaponnum, struct weaponfunc *funcdef); diff --git a/src/include/game/filemgr.h b/src/include/game/filemgr.h index c0f63bad8..80695df9d 100644 --- a/src/include/game/filemgr.h +++ b/src/include/game/filemgr.h @@ -16,7 +16,7 @@ void filemgrSetFileToDelete(struct filelistfile *file, s32 filetype); char *filemgrMenuTextFailReason(struct menuitem *item); char *filemgrMenuTextDeviceNameForError(struct menuitem *item); void filemgrPushErrorDialog(u16 errnum); -s32 filemgrGetDeviceNameOrStartIndex(s32 listnum, s32 operation, s32 optionindex); +uintptr_t filemgrGetDeviceNameOrStartIndex(s32 listnum, s32 operation, s32 optionindex); char *filemgrMenuTextErrorTitle(struct menuitem *item); char *filemgrMenuTextFileType(struct menuitem *item); void func0f10898c(void); diff --git a/src/include/game/texdecompress.h b/src/include/game/texdecompress.h index a6d92d548..4fc372967 100644 --- a/src/include/game/texdecompress.h +++ b/src/include/game/texdecompress.h @@ -33,7 +33,7 @@ s32 texGetPoolFreeBytes(struct texpool *pool); u8 *texGetPoolLeftPos(struct texpool *pool); void texLoadFromDisplayList(Gfx *gdl, struct texpool *pool, s32 arg2); void texLoad(texnum_t *updateword, struct texpool *pool, bool unusedarg); -void texLoadFromConfigs(struct textureconfig *configs, s32 numconfigs, struct texpool *pool, s32 arg3); +void texLoadFromConfigs(struct textureconfig *configs, s32 numconfigs, struct texpool *pool, uintptr_t arg3); void texLoadFromTextureNum(u32 arg0, struct texpool *pool); #ifndef PLATFORM_N64 void texSwizzleInternal(u8 *dst, s32 width, s32 height, s32 format, u32 dstlen); diff --git a/src/include/lib/mema.h b/src/include/lib/mema.h index c83878ef6..29f4b754b 100644 --- a/src/include/lib/mema.h +++ b/src/include/lib/mema.h @@ -6,13 +6,13 @@ void memaDefrag(void); void memaInit(void); -void memaReset(void *ptr, u32 size); +void memaReset(void *ptr, u64 size); void memaPrint(void); -void *memaAlloc(u32 size); -s32 memaGrow(s32 addr, u32 amount); -void _memaFree(s32 addr, s32 size); -void memaFree(void *addr, s32 size); -s32 memaGetLongestFree(void); -bool memaRealloc(s32 addr, u32 oldsize, u32 newsize); +void *memaAlloc(u64 size); +uintptr_t memaGrow(uintptr_t addr, u64 amount); +void _memaFree(uintptr_t addr, u64 size); +void memaFree(void *addr, u64 size); +u64 memaGetLongestFree(void); +bool memaRealloc(uintptr_t addr, u64 oldsize, u64 newsize); #endif diff --git a/src/include/lib/mp3.h b/src/include/lib/mp3.h index 6369dd7e8..92b720046 100644 --- a/src/include/lib/mp3.h +++ b/src/include/lib/mp3.h @@ -5,7 +5,7 @@ #include "types.h" void mp3Init(ALHeap *heap); -void mp3PlayFile(s32 romaddr, s32 filesize); +void mp3PlayFile(uintptr_t romaddr, s32 filesize); void func00037e1c(void); void func00037e38(void); void func00037e68(void); diff --git a/src/include/lib/snd.h b/src/include/lib/snd.h index 0b96846c3..0f1056039 100644 --- a/src/include/lib/snd.h +++ b/src/include/lib/snd.h @@ -12,11 +12,11 @@ void snd0000ea80(u16 volume); void sndResetCurMp3(void); void sndLoadSfxCtl(void); void sndIncrementAges(void); -ALEnvelope *sndLoadEnvelope(u32 offset, u16 index); -ALKeyMap *sndLoadKeymap(u32 offset, u16 index); -ALADPCMBook *sndLoadAdpcmBook(u32 offset, u16 index); -ALADPCMloop *sndLoadAdpcmLoop(u32 offset, u16 index); -ALWaveTable *sndLoadWavetable(u32 offset, u16 index); +ALEnvelope *sndLoadEnvelope(uintptr_t offset, u16 index); +ALKeyMap *sndLoadKeymap(uintptr_t offset, u16 index); +ALADPCMBook* sndLoadAdpcmBook(uintptr_t offset, u16 index); +ALADPCMloop* sndLoadAdpcmLoop(uintptr_t offset, u16 index); +ALWaveTable* sndLoadWavetable(uintptr_t offset, u16 index); void sndSetSoundMode(s32 mode); ALSound *sndLoadSound(s16 soundnum); void seqInit(struct seqinstance *seq); diff --git a/src/include/types.h b/src/include/types.h index 3a5059392..a2e66417f 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -2307,7 +2307,7 @@ struct hand { /*0x0dc0*/ u32 fspare8; /*0x0dc4*/ struct abmag abmag; /*0x0dcc*/ s32 *unk0dcc; - /*0x0dd0*/ s32 *unk0dd0; + /*0x0dd0*/ uintptr_t *unk0dd0; /*0x0dd4*/ s32 unk0dd4; /*0x0dd8*/ Mtxf *unk0dd8; }; @@ -2354,8 +2354,8 @@ struct gunctrl { /*0x15b1*/ u8 gunloadstate; /*0x15b2*/ u16 loadfilenum; /*0x15b4*/ struct modeldef **loadtomodeldef; - /*0x15b8*/ u32 *loadmemptr; - /*0x15bc*/ u32 *loadmemremaining; + /*0x15b8*/ uintptr_t *loadmemptr; + /*0x15bc*/ uintptr_t*loadmemremaining; /*0x15c0*/ struct texpool texpool; /*0x15d0*/ u32 nexttexturetoload; /*0x15d4*/ struct fileinfo fileinfo; @@ -3363,8 +3363,8 @@ struct handlerdata_label { struct handlerdata_list { union { - u32 value; - s32 values32; + uintptr_t value; + intptr_t values32; }; union { s32 unk04; diff --git a/src/lib/mema.c b/src/lib/mema.c index e0dccdf14..d0676ccff 100644 --- a/src/lib/mema.c +++ b/src/lib/mema.c @@ -38,8 +38,8 @@ #define MAX_SPACES 124 struct memaspace { - s32 addr; - u32 size; + uintptr_t addr; + u64 size; }; /** @@ -55,8 +55,8 @@ struct memaheap { struct memaspace end2; }; -s32 g_MemaHeapStart; -s32 g_MemaHeapSize; +uintptr_t g_MemaHeapStart; +u64 g_MemaHeapSize; struct memaheap g_MemaHeap; #if VERSION == VERSION_PAL_BETA @@ -65,8 +65,8 @@ u32 g_MemaLeastEverFree = 1000000; void memaSwap(struct memaspace *a, struct memaspace *b) { - u32 tempaddr = a->addr; - u32 tempsize = a->size; + uintptr_t tempaddr = a->addr; + u64 tempsize = a->size; a->addr = b->addr; a->size = b->size; b->addr = tempaddr; @@ -86,7 +86,7 @@ bool memaDefragPass(struct memaheap *heap) struct memaspace *prev = &heap->start; struct memaspace *curr = &heap->spaces[0]; struct memaspace *last = &heap->spaces[MAX_SPACES - 1]; - u32 addr = 0; + uintptr_t addr = 0; while (curr <= last) { if (curr->size != 0) { @@ -177,7 +177,7 @@ struct memaspace *memaMakeSlot(struct memaheap *heap) return best; } -void _memaFree(s32 addr, s32 size) +void _memaFree(uintptr_t addr, u64 size) { // Choose an index in the spaces array which we'll mark a space as free, // based on how far into the heap the allocation is. This is a rough @@ -215,7 +215,7 @@ void memaInit(void) // empty } -void memaReset(void *heapaddr, u32 heapsize) +void memaReset(void *heapaddr, u64 heapsize) { struct memaspace *space; @@ -398,14 +398,14 @@ void memaPrint(void) #endif } -void *memaAlloc(u32 size) +void *memaAlloc(u64 size) { uintptr_t addr; - u32 diff; + uintptr_t diff; s32 i; struct memaspace *curr; - u32 bestdiff; + uintptr_t bestdiff; struct memaspace *best; if (1); @@ -487,7 +487,7 @@ void *memaAlloc(u32 size) /** * Grow the allocation which currently *ends at* the given address. */ -s32 memaGrow(s32 addr, u32 amount) +uintptr_t memaGrow(uintptr_t addr, u64 amount) { struct memaspace *curr = &g_MemaHeap.spaces[0]; @@ -512,7 +512,7 @@ found: return addr; } -void memaFree(void *addr, s32 size) +void memaFree(void *addr, u64 size) { _memaFree((uintptr_t) addr, size); } @@ -526,7 +526,7 @@ void mema00012cd4(void) * Find and return the largest amount of contiguous free space in the pool. * ie. the biggest allocation that mema can currently make. */ -s32 memaGetLongestFree(void) +u64 memaGetLongestFree(void) { struct memaspace *curr; s32 biggest = 0; @@ -550,7 +550,7 @@ s32 memaGetLongestFree(void) return 0; } -bool memaRealloc(s32 addr, u32 oldsize, u32 newsize) +bool memaRealloc(uintptr_t addr, u64 oldsize, u64 newsize) { if (newsize > oldsize) { if (!memaGrow(addr + oldsize, newsize - oldsize)) { diff --git a/src/lib/mp3.c b/src/lib/mp3.c index 270340c1d..9f69e9ac5 100644 --- a/src/lib/mp3.c +++ b/src/lib/mp3.c @@ -88,7 +88,7 @@ void mp3Init(ALHeap *heap) func00038b90(func00038ba8); } -void mp3PlayFile(s32 romaddr, s32 filesize) +void mp3PlayFile(uintptr_t romaddr, s32 filesize) { if (g_Mp3Vars.var8009c3dc == NULL) { return; @@ -389,7 +389,7 @@ void func00038b90(void *fn) s32 func00038ba8(s32 arg0, u8 *arg1, s32 arg2, s32 arg3) { - u32 sp1c; + uintptr_t sp1c; ALDMAproc proc; if (arg3 != -1) { diff --git a/src/lib/naudio/n_load.c b/src/lib/naudio/n_load.c index 365774c4d..aa8070356 100644 --- a/src/lib/naudio/n_load.c +++ b/src/lib/naudio/n_load.c @@ -258,7 +258,7 @@ s32 n_alLoadParam(N_PVoice *filter, s32 paramID, void *param) Acmd *_decodeChunk(Acmd *ptr, N_PVoice *f, s32 tsam, s32 nbytes, s16 outp, s16 inp, u32 flags) { - s32 dramAlign, dramLoc; + intptr_t dramAlign, dramLoc; if (nbytes > 0) { dramLoc = (f->dc_dma)(f->dc_memin, nbytes, f->dc_dmaState); diff --git a/src/lib/snd.c b/src/lib/snd.c index 0abedf5a8..e130cdb0f 100644 --- a/src/lib/snd.c +++ b/src/lib/snd.c @@ -952,7 +952,7 @@ void sndLoadSfxCtl(void) u8 *buffer; ALBankFile *file; ALBank *bank; - u32 romaddr; + romptr_t romaddr; u32 size; g_ALSoundRomOffsets = NULL; @@ -966,14 +966,14 @@ void sndLoadSfxCtl(void) // then load the first 256 bytes of the bank. file = (ALBankFile *) buffer; romaddr = (romptr_t) REF_SEG _sfxctlSegmentRomStart; - romaddr += (u32)file->bankArray[0]; + romaddr += (uintptr_t)file->bankArray[0]; dmaExec(buffer, romaddr, size); // Get the ROM address of the first (and only) instrument, // then load the first 256 bytes of the instrument. bank = (ALBank *) buffer; romaddr = (romptr_t) REF_SEG _sfxctlSegmentRomStart; - romaddr += (u32)bank->instArray[0]; + romaddr += (uintptr_t)bank->instArray[0]; dmaExec(buffer, romaddr, size); // Get the soundCount (spoiler: there's 1545+1). @@ -1027,7 +1027,7 @@ void sndIncrementAges(void) } #endif -ALEnvelope *sndLoadEnvelope(u32 offset, u16 cacheindex) +ALEnvelope *sndLoadEnvelope(uintptr_t offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 u8 spaf[0x90]; @@ -1074,7 +1074,7 @@ ALEnvelope *sndLoadEnvelope(u32 offset, u16 cacheindex) return s1; } -ALKeyMap *sndLoadKeymap(u32 offset, u16 cacheindex) +ALKeyMap *sndLoadKeymap(uintptr_t offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 u8 spaf[0x90]; @@ -1121,7 +1121,7 @@ ALKeyMap *sndLoadKeymap(u32 offset, u16 cacheindex) return s1; } -ALADPCMBook *sndLoadAdpcmBook(u32 offset, u16 cacheindex) +ALADPCMBook *sndLoadAdpcmBook(uintptr_t offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 u8 spaf[0x150]; @@ -1168,7 +1168,7 @@ ALADPCMBook *sndLoadAdpcmBook(u32 offset, u16 cacheindex) return s1; } -ALADPCMloop *sndLoadAdpcmLoop(u32 offset, u16 cacheindex) +ALADPCMloop *sndLoadAdpcmLoop(uintptr_t offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 u8 spaf[0x90]; @@ -1223,7 +1223,7 @@ ALADPCMloop *sndLoadAdpcmLoop(u32 offset, u16 cacheindex) return s1; } -ALWaveTable *sndLoadWavetable(u32 offset, u16 cacheindex) +ALWaveTable *sndLoadWavetable(uintptr_t offset, u16 cacheindex) { #if VERSION >= VERSION_NTSC_1_0 u8 spaf[0x90]; diff --git a/src/lib/ultra/audio/bnkf.c b/src/lib/ultra/audio/bnkf.c index 3715d4280..0a8b41009 100644 --- a/src/lib/ultra/audio/bnkf.c +++ b/src/lib/ultra/audio/bnkf.c @@ -3,14 +3,14 @@ #include #include "types.h" -void _bnkfPatchBank(ALBank *bank, s32 offset, s32 table); -void _bnkfPatchInst(ALInstrument *inst, s32 offset, s32 table); -void _bnkfPatchSound(ALSound *s, s32 offset, s32 table); -void _bnkfPatchWaveTable(ALWaveTable *w, s32 offset, s32 table); +void _bnkfPatchBank(ALBank *bank, uintptr_t offset, uintptr_t table); +void _bnkfPatchInst(ALInstrument* inst, uintptr_t offset, uintptr_t table); +void _bnkfPatchSound(ALSound* s, uintptr_t offset, uintptr_t table); +void _bnkfPatchWaveTable(ALWaveTable* w, uintptr_t offset, uintptr_t table); void alSeqFileNew(ALSeqFile *file, u8 *base) { - intptr_t offset = (intptr_t) base; + uintptr_t offset = (uintptr_t) base; s32 i; /* @@ -23,8 +23,8 @@ void alSeqFileNew(ALSeqFile *file, u8 *base) void alBnkfNew(ALBankFile *file, u8 *table) { - intptr_t offset = (intptr_t) file; - intptr_t woffset = (intptr_t) table; + uintptr_t offset = (uintptr_t) file; + uintptr_t woffset = (uintptr_t) table; s32 i; @@ -45,7 +45,7 @@ void alBnkfNew(ALBankFile *file, u8 *table) } } -void _bnkfPatchBank(ALBank *bank, s32 offset, s32 table) +void _bnkfPatchBank(ALBank *bank, uintptr_t offset, uintptr_t table) { s32 i; @@ -69,7 +69,7 @@ void _bnkfPatchBank(ALBank *bank, s32 offset, s32 table) } } -void _bnkfPatchInst(ALInstrument *inst, s32 offset, s32 table) +void _bnkfPatchInst(ALInstrument *inst, uintptr_t offset, uintptr_t table) { s32 i; @@ -85,7 +85,7 @@ void _bnkfPatchInst(ALInstrument *inst, s32 offset, s32 table) } } -void _bnkfPatchSound(ALSound *s, s32 offset, s32 table) +void _bnkfPatchSound(ALSound *s, uintptr_t offset, uintptr_t table) { if (s->flags) { return; @@ -100,7 +100,7 @@ void _bnkfPatchSound(ALSound *s, s32 offset, s32 table) _bnkfPatchWaveTable(s->wavetable, offset, table); } -void _bnkfPatchWaveTable(ALWaveTable *w, s32 offset, s32 table) +void _bnkfPatchWaveTable(ALWaveTable *w, uintptr_t offset, uintptr_t table) { if (w->flags) { return; From 32faea2b95ebcb9019e8904e2a10c28e1235fac6 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Tue, 30 Jul 2024 16:47:12 +0800 Subject: [PATCH 08/81] portx64: gbi changes --- include/PR/gbi.h | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/include/PR/gbi.h b/include/PR/gbi.h index 27993ea61..c970c3997 100644 --- a/include/PR/gbi.h +++ b/include/PR/gbi.h @@ -23,6 +23,11 @@ #include #include "gbiex.h" +#ifndef PLATFORM_N64 +#include "platform.h" +#endif + + /* * To use the F3DEX ucodes, define F3DEX_GBI before include this file. * @@ -594,10 +599,10 @@ #define G_BL_0 3 #define GBL_c1(m1a, m1b, m2a, m2b) \ - (m1a) << 30 | (m1b) << 26 | (m2a) << 22 | (m2b) << 18 + (u32)(m1a) << 30 | (u32)(m1b) << 26 | (u32)(m2a) << 22 | (u32)(m2b) << 18 #define GBL_c2(m1a, m1b, m2a, m2b) \ - (m1a) << 28 | (m1b) << 24 | (m2a) << 20 | (m2b) << 16 + (u32)(m1a) << 28 | (u32)(m1b) << 24 | (u32)(m2a) << 20 | (u32)(m2b) << 16 #define RM_AA_ZB_OPA_SURF(clk) \ AA_EN | Z_CMP | Z_UPD | IM_RD | CVG_DST_CLAMP | \ @@ -1306,6 +1311,14 @@ typedef union { /* * Graphics DMA Packet */ +#ifdef PLATFORM_64BIT +typedef struct { + intptr_t par : 24; + intptr_t cmd : 8; + intptr_t len : 32; + uintptr_t addr; +} Gdma; +#else typedef struct { #ifdef PLATFORM_BIG_ENDIAN int cmd:8; @@ -1319,6 +1332,7 @@ typedef struct { unsigned int addr; #endif } Gdma; +#endif /* * Graphics Immediate Mode Packet types @@ -1357,6 +1371,9 @@ typedef struct { unsigned char z4:4; unsigned char pad:8; unsigned char cmd:8; +#ifdef PLATFORM_64BIT + unsigned char pad2[4]; +#endif unsigned char x1:4; unsigned char y1:4; unsigned char x2:4; @@ -1365,6 +1382,9 @@ typedef struct { unsigned char y3:4; unsigned char x4:4; unsigned char y4:4; +#ifdef PLATFORM_64BIT + unsigned char pad3[4]; +#endif #endif } Gtri4; @@ -1633,6 +1653,9 @@ typedef union { #ifdef PLATFORM_BIG_ENDIAN #define GFX_W0_BYTE(i) (i) #define GFX_W1_BYTE(i) (4 + (i)) +#elif PLATFORM_64BIT +#define GFX_W0_BYTE(i) (3 - (i)) +#define GFX_W1_BYTE(i) (11 - (i)) #else #define GFX_W0_BYTE(i) (3 - (i)) #define GFX_W1_BYTE(i) (7 - (i)) From ef4b60d384a1c398adf6e8e3021f799dba90434a Mon Sep 17 00:00:00 2001 From: Raf <> Date: Tue, 30 Jul 2024 16:57:17 +0800 Subject: [PATCH 09/81] portx64: audio system changes --- include/PR/n_libaudio.h | 12 +++++++++++- src/game/propsndstop.c | 1 + src/lib/mp3/mp3.h | 3 +++ src/lib/naudio/n_reverb.c | 8 ++++---- src/lib/snd.c | 10 +++++++--- src/lib/ultra/audio/synthInternals.h | 3 +++ 6 files changed, 29 insertions(+), 8 deletions(-) diff --git a/include/PR/n_libaudio.h b/include/PR/n_libaudio.h index 4f82c2471..5a06e9558 100644 --- a/include/PR/n_libaudio.h +++ b/include/PR/n_libaudio.h @@ -256,7 +256,7 @@ typedef struct { ALOscStop stopOsc; ALSeqMarker *loopStart; ALSeqMarker *loopEnd; - s32 loopCount; /* -1 = loop forever, 0 = no loop */ + intptr_t loopCount; /* -1 = loop forever, 0 = no loop */ u8 unk88; u8 unk89; } N_ALSeqPlayer; @@ -284,9 +284,19 @@ typedef struct { ALOscInit initOsc; ALOscUpdate updateOsc; ALOscStop stopOsc; + +#ifdef PLATFORM_64BIT + s32 _pad1_; + f32 unk7c; + s32 _pad2_; + f32 unk80; +#else f32 unk7c; f32 unk80; +#endif + void *queue; + u8 unk88; u8 unk89; } N_ALCSPlayer; diff --git a/src/game/propsndstop.c b/src/game/propsndstop.c index 93f2df6a1..4891021cb 100644 --- a/src/game/propsndstop.c +++ b/src/game/propsndstop.c @@ -8,6 +8,7 @@ void psStop(void) { + if (g_SndDisabled) return; s32 i; for (i = 0; i < (IS4MB() ? 30 : 40); i++) { diff --git a/src/lib/mp3/mp3.h b/src/lib/mp3/mp3.h index 14ac2c6f6..eab395a1c 100644 --- a/src/lib/mp3/mp3.h +++ b/src/lib/mp3/mp3.h @@ -7,6 +7,9 @@ struct mp3decfourbytes { u8 bytes[2]; s8 unk02; s8 unk03; +#ifdef PLATFORM_64BIT + u32 _pad_; +#endif }; struct asistream_scalefac { diff --git a/src/lib/naudio/n_reverb.c b/src/lib/naudio/n_reverb.c index 39657dd89..98c5e30b9 100644 --- a/src/lib/naudio/n_reverb.c +++ b/src/lib/naudio/n_reverb.c @@ -47,8 +47,8 @@ Acmd *n_alFxPull(s32 sampleOffset, Acmd *p, s32 arg2) for (i = 0; i < r->section_count; i++) { d = &r->delay[i]; /* get the ALDelay structure */ - in_ptr = &r->input[j][-d->input]; - out_ptr = &r->input[j][-d->output]; + in_ptr = &r->input[j][(s32)-d->input]; + out_ptr = &r->input[j][(s32)-d->output]; if (var8009c346[arg2] && var8009c344[arg2]) { d->ffcoef = -d->ffcoef; @@ -253,7 +253,7 @@ Acmd *_n_loadOutputBuffer(ALFx *r, ALDelay *d, s32 arg2, s32 buff, Acmd *p) fincount = d->rs->delta + (fratio * (f32)incount); count = (s32) fincount; d->rs->delta = fincount - (f32)count; - out_ptr = &r->input[arg2][-(d->output - d->rsdelta)]; + out_ptr = &r->input[arg2][(s32)-(d->output - d->rsdelta)]; ramalign = ((intptr_t)out_ptr & 0x7) >> 1; ptr = _n_loadBuffer(r, arg2, out_ptr - ramalign, rbuff, count + ramalign, ptr); @@ -265,7 +265,7 @@ Acmd *_n_loadOutputBuffer(ALFx *r, ALDelay *d, s32 arg2, s32 buff, Acmd *p) d->rs->first = 0; d->rsdelta += count - incount; } else { - out_ptr = &r->input[arg2][-d->output]; + out_ptr = &r->input[arg2][(s32)-d->output]; ptr = _n_loadBuffer(r, arg2, out_ptr, buff, FIXED_SAMPLE, ptr); } diff --git a/src/lib/snd.c b/src/lib/snd.c index e130cdb0f..6beac208b 100644 --- a/src/lib/snd.c +++ b/src/lib/snd.c @@ -105,6 +105,8 @@ s32 var8005dddc = 0; u8 *g_SndGuardStringPtr = NULL; +uintptr_t* g_SeqRomAddrs; + enum audioconfig_e { AUDIOCONFIG_00, AUDIOCONFIG_01, @@ -1526,8 +1528,10 @@ void sndInit(void) dmaExec(g_SeqTable, (romptr_t) REF_SEG _sequencesSegmentRomStart, (len + 0xf) & ~0xf); // Promote segment-relative offsets to ROM addresses + g_SeqRomAddrs = mempAlloc(g_SeqTable->count * sizeof(uintptr_t), MEMPOOL_PERMANENT); + for (i = 0; i < g_SeqTable->count; i++) { - g_SeqTable->entries[i].romaddr += (romptr_t) REF_SEG _sequencesSegmentRomStart; + g_SeqRomAddrs[i] = g_SeqTable->entries[i].romaddr + (romptr_t) REF_SEG _sequencesSegmentRomStart; } synconfig.maxVVoices = 44; @@ -1639,7 +1643,7 @@ bool seqPlay(struct seqinstance *seq, s32 tracknum) return false; } - if (g_SeqTable->entries[seq->tracknum].romaddr < 0x10000) { + if (g_SeqRomAddrs[seq->tracknum] < 0x10000) { return false; } @@ -1688,7 +1692,7 @@ bool seqPlay(struct seqinstance *seq, s32 tracknum) binstart = seq->data; zipstart = binstart + binlen - ziplen; - dmaExec(zipstart, g_SeqTable->entries[seq->tracknum].romaddr, ziplen); + dmaExec(zipstart, g_SeqRomAddrs[seq->tracknum], ziplen); ziplen = rzipInflate(zipstart, binstart, scratch); } diff --git a/src/lib/ultra/audio/synthInternals.h b/src/lib/ultra/audio/synthInternals.h index 4e9dbd31e..89ab4cf7e 100644 --- a/src/lib/ultra/audio/synthInternals.h +++ b/src/lib/ultra/audio/synthInternals.h @@ -107,6 +107,9 @@ typedef struct ALParam_s { } yetstillmoredata; s32 unk1c; s32 unk20; +#ifdef PLATFORM_64BIT + u8 _pad_[8]; +#endif } ALParam; typedef struct { From 10a3992a62145075ee374cb393308366f0abcfdc Mon Sep 17 00:00:00 2001 From: Raf <> Date: Tue, 30 Jul 2024 17:34:06 +0800 Subject: [PATCH 10/81] portx64: pd-extract: bg (extract roomgfxdata) and some model fixes --- port/pdextract/common.h | 55 ++++- port/pdextract/ext_file_bg.c | 390 ++++++++++++++++++++++++++++---- port/pdextract/ext_file_model.c | 64 +++++- port/pdextract/gbi.c | 186 ++++++++------- 4 files changed, 540 insertions(+), 155 deletions(-) diff --git a/port/pdextract/common.h b/port/pdextract/common.h index 50f777ad0..f6f1387b6 100644 --- a/port/pdextract/common.h +++ b/port/pdextract/common.h @@ -1,20 +1,48 @@ -#ifndef _COMMON_H -#define _COMMON_H +#ifndef _PDE_COMMON_H +#define _PDE_COMMON_H + #include #include #include -#define srctoh16(value) be16toh(value) -#define srctoh32(value) be32toh(value) -#define srctoh64(value) be64toh(value) +#include +#include + +#if __BIG_ENDIAN__ + #define htonll(x) (x) + #define ntohll(x) (x) +#else + #define htonll(x) ((((uint64_t)htonl(x&0xFFFFFFFF)) << 32) + htonl(x >> 32)) + #define ntohll(x) ((((uint64_t)ntohl(x&0xFFFFFFFF)) << 32) + ntohl(x >> 32)) +#endif + +#define htobe16(x) htons(x) +#define htole16(x) (x) +#define be16toh(x) ntohs(x) +#define le16toh(x) (x) + +#define htobe32(x) htonl(x) +#define htole32(x) (x) +#define be32toh(x) ntohl(x) +#define le32toh(x) (x) + +#define htobe64(x) htonll(x) +#define htole64(x) (x) +#define be64toh(x) ntohll(x) +#define le64toh(x) (x) + + +#define srctoh16(value) ntohs(value) +#define srctoh32(value) ntohl(value) +#define srctoh64(value) ntohll(value) #ifdef FORCE_BE32 -#define htodst16(value) htobe16(value) -#define htodst32(value) htobe32(value) -#define htodst64(value) htobe64(value) -#define dsttoh16(value) be16toh(value) -#define dsttoh32(value) be32toh(value) -#define dsttoh64(value) be64toh(value) +#define htodst16(value) htons(value) +#define htodst32(value) htonl(value) +#define htodst64(value) htonll(value) +#define dsttoh16(value) ntohs(value) +#define dsttoh32(value) ntohl(value) +#define dsttoh64(value) ntohll(value) #else #define htodst16(value) (value) #define htodst32(value) (value) @@ -66,6 +94,9 @@ int rzip_deflate(uint8_t *dst, size_t *dstlen, uint8_t *src, size_t srclen); void gbi_reset(void); void gbi_set_segment(int segment, uint32_t offset); void gbi_set_vtx(uint32_t src_offset, uint32_t dst_offset); -uint32_t gbi_convert_gdl(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos); +uint32_t gbi_convert_gdl(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, int segment_cmds); +void gbi_convert_vtx(uint8_t* dst, uint32_t dstpos, int count); +void gbi_gdl_rewrite_addrs(uint8_t* dst, uint32_t offset); +void gbi_add_tex_addr(uint32_t src_offset, uint32_t dst_offset); #endif diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c index ec8a15a07..1c2921ffe 100644 --- a/port/pdextract/ext_file_bg.c +++ b/port/pdextract/ext_file_bg.c @@ -3,6 +3,45 @@ #include #include #include "common.h" +#include "system.h" + +struct ptrmarker { + uint32_t ptr_src; + uintptr_t ptr_host; +}; + + +struct ptrmarker m_PtrMarkers[2048]; +int m_NumPtrMarkers; +int m_SizeGDLs; + +static void add_marker(uint32_t ptr_src, uintptr_t ptr_host) +{ + if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { + fprintf(stderr, "[BG] Marker limit exceeded\n"); + exit(EXIT_FAILURE); + } + + m_PtrMarkers[m_NumPtrMarkers].ptr_src = ptr_src; + m_PtrMarkers[m_NumPtrMarkers].ptr_host = ptr_host; + m_NumPtrMarkers++; +} + +static struct ptrmarker* find_marker(uintptr_t ptr_src) +{ + for (int i = 0; i < m_NumPtrMarkers; i++) { + if (m_PtrMarkers[i].ptr_src == ptr_src) { + return &m_PtrMarkers[i]; + } + } + + return NULL; +} + +static void reset_markers() +{ + m_NumPtrMarkers = 0; +} /** * 4 bytes decompressed size of primary data @@ -113,9 +152,57 @@ struct light { int16_t bbox[4][3]; }; +struct n64_roomblock { + uint8_t type; + uint32_t ptr_next; + uint32_t ptr_gdl; + uint32_t ptr_vertices; + uint32_t ptr_colours; +}; + +struct host_roomblock { + uint8_t type; + uintptr_t ptr_next; + uintptr_t ptr_gdl; + uintptr_t ptr_vertices; + uintptr_t ptr_colours; +}; + +struct n64_roomgfxdata { + uint32_t ptr_vertices; + uint32_t ptr_colours; + uint32_t ptr_opablocks; + uint32_t ptr_xlublocks; + int16_t lightsindex; + int16_t numlights; + int16_t numvertices; + int16_t numcolours; + // roomblocks[] +}; + +struct host_roomgfxdata { + uintptr_t ptr_vertices; + uintptr_t ptr_colours; + uintptr_t ptr_opablocks; + uintptr_t ptr_xlublocks; + int16_t lightsindex; + int16_t numlights; + int16_t numvertices; + int16_t numcolours; + // roomblocks[] +}; + +struct vtx { + int16_t coord[3]; + uint8_t flag; + uint8_t color; + uint16_t s; + uint16_t t; +}; + int m_NumRooms; -uint16_t m_AllocSizes[512]; +uint32_t m_AllocSizes[512]; static void convert_primary_rooms(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) { @@ -137,11 +224,11 @@ static void convert_primary_rooms(uint8_t *dst, uint32_t *dstpos, uint8_t *src, host_rooms[i].br_light_max = n64_rooms[i].br_light_max; } - *srcpos += sizeof(*n64_rooms) * (m_NumRooms + 1); - *dstpos += sizeof(*host_rooms) * (m_NumRooms + 1); + *srcpos += sizeof(*n64_rooms) * (m_NumRooms + 2); + *dstpos += sizeof(*host_rooms) * (m_NumRooms +2); } -static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t *src_portalvtxs, uint32_t *dst_portalvtxs) { struct portal *n64_portals = (struct portal *) &src[*srcpos]; struct portal *host_portals = (struct portal *) &dst[*dstpos]; @@ -164,13 +251,12 @@ static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src *srcpos += sizeof(*n64_portals) * (numportals + 1); *dstpos += sizeof(*host_portals) * (numportals + 1); - // Convert portal vertices - uint8_t *n64_vtxdata = &src[*srcpos]; - uint8_t *host_vtxdata = &dst[*dstpos]; + *src_portalvtxs = *srcpos; + *dst_portalvtxs = *dstpos; - for (int i = 0; i < numportals; i++) { - struct portalvertices *n64_pvertices = (struct portalvertices*) &n64_vtxdata[*srcpos]; - struct portalvertices *host_pvertices = (struct portalvertices*) &host_vtxdata[*dstpos]; + while (1) { + struct portalvertices *n64_pvertices = (struct portalvertices*)&src[*srcpos]; + struct portalvertices *host_pvertices = (struct portalvertices*)&dst[*dstpos]; host_pvertices->count = n64_pvertices->count; @@ -182,10 +268,12 @@ static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src *srcpos += 4 + host_pvertices->count * 12; *dstpos += 4 + host_pvertices->count * 12; + + if (host_pvertices->count == 0) break; } } -static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t dst_portalvtxs, uint32_t src_portalvtxs) { struct bgcmd *n64_cmds = (struct bgcmd *) &src[*srcpos]; struct bgcmd *host_cmds = (struct bgcmd *) &dst[*dstpos]; @@ -201,6 +289,11 @@ static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, host_cmds[i].type = n64_cmds[i].type; host_cmds[i].len = n64_cmds[i].len; host_cmds[i].param = srctodst32(n64_cmds[i].param); + + if (host_cmds[i].type == 0x64) { + uint32_t offset = host_cmds[i].param - src_portalvtxs; + host_cmds[i].param = dst_portalvtxs + offset; + } } *srcpos += sizeof(*n64_cmds) * num_cmds; @@ -238,21 +331,196 @@ static void convert_primary_lights(uint8_t *dst, uint32_t *dstpos, uint8_t *src, *dstpos += sizeof(*host_lights) * num_lights; } -static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos) +#define BLOCK_LEAF 0 +#define BLOCK_PARENT 1 + +void relink_ptr(uintptr_t** ptr) { - return dstpos; + if (!*ptr) return; + + struct ptrmarker* marker = find_marker(*ptr); + if (!marker) { + fprintf(stderr, "[BG] WARNING: Unable to relink pointer: %p\n", ptr); + exit(EXIT_FAILURE); + } + + *ptr = marker->ptr_host; } -static size_t sum(uint8_t *ptr, uint8_t *end) +static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t compsize, uint32_t src_roomoffset, uint32_t dst_roomoffset) { - size_t sum = 0; + reset_markers(); + dst_roomoffset += 0x0f000000; + size_t infsize = rzip_get_infsize(src); + uint8_t* src_roomgfxdata = calloc(1, infsize); - while (ptr < end) { - sum = (sum + *ptr) & 0xffffffff; - ptr++; + int ret = rzip_inflate(src_roomgfxdata, infsize, src, compsize); + + if (ret < 0) { + fprintf(stderr, "Unable to inflate roomgfxdata %d\n", ret); + exit(EXIT_FAILURE); } - return sum; + uintptr_t gdls_addr[64]; + int numgdls = 0; + + struct n64_roomgfxdata *src_header = (struct n64_roomgfxdata*)src_roomgfxdata; + struct host_roomgfxdata *dst_header = (struct host_roomgfxdata*)&dst[dstpos]; + + dst_header->ptr_vertices = srctoh32(src_header->ptr_vertices); + dst_header->ptr_colours = srctoh32(src_header->ptr_colours); + dst_header->ptr_opablocks = srctoh32(src_header->ptr_opablocks); + dst_header->ptr_xlublocks = srctoh32(src_header->ptr_xlublocks); + dst_header->lightsindex = srctoh16(src_header->lightsindex); + dst_header->numlights = srctoh16(src_header->numlights); + dst_header->numvertices = srctoh16(src_header->numvertices); + dst_header->numcolours = srctoh16(src_header->numcolours); + + intptr_t endpos = dst_header->ptr_vertices - src_roomoffset; + uintptr_t curpos_src = sizeof(struct n64_roomgfxdata); + uintptr_t curpos_dst = sizeof(struct host_roomgfxdata); + + // roomblocks + int ncoords = 0; + + // save the ptr to roomblocks here to iterate later to fix the pointers + struct host_roomblock *ptr_dst_roomblocks = (struct host_roomblock*)&dst[curpos_dst]; + + int numblocks = 0; + while ((intptr_t)(curpos_src + sizeof(struct n64_roomblock)) <= endpos) { + struct n64_roomblock *src_roomblock = (struct n64_roomblock*)&src_roomgfxdata[curpos_src]; + struct host_roomblock *dest_roomblock = (struct host_roomblock*)&dst[curpos_dst]; + + dest_roomblock->type = src_roomblock->type; + dest_roomblock->ptr_next = srctoh32(src_roomblock->ptr_next); + dest_roomblock->ptr_gdl = srctoh32(src_roomblock->ptr_gdl); + dest_roomblock->ptr_vertices = srctoh32(src_roomblock->ptr_vertices); + dest_roomblock->ptr_colours = srctoh32(src_roomblock->ptr_colours); + + add_marker(curpos_src + src_roomoffset, curpos_dst + dst_roomoffset); + + if (src_roomblock->type == BLOCK_PARENT) { + ncoords++; + uintptr_t vtx_ptr = dest_roomblock->ptr_vertices - src_roomoffset; + if (vtx_ptr < endpos) endpos = vtx_ptr; + } + else if (src_roomblock->ptr_gdl) { + gdls_addr[numgdls++] = srctoh32(src_roomblock->ptr_gdl) - src_roomoffset; + } + + curpos_src += sizeof(struct n64_roomblock); + curpos_dst += sizeof(struct host_roomblock); + numblocks++; + } + + // block coords + for (size_t i = 0; i < ncoords; i++) { + uint32_t *src_coord = (uint32_t*)(src_roomgfxdata + curpos_src); + uint32_t *dst_coord = (uint32_t*)(dst + curpos_dst); + + dst_coord[0] = srctoh32(src_coord[0]); + dst_coord[1] = srctoh32(src_coord[1]); + dst_coord[2] = srctoh32(src_coord[2]); + + dst_coord[3] = srctoh32(src_coord[3]); + dst_coord[4] = srctoh32(src_coord[4]); + dst_coord[5] = srctoh32(src_coord[5]); + + add_marker(curpos_src + src_roomoffset, curpos_dst + dst_roomoffset); + + curpos_src += 6 * sizeof(uint32_t); + curpos_dst += 6 * sizeof(uint32_t); + } + + curpos_dst = ALIGN8(curpos_dst); + + // vertices + uintptr_t ptr_src_vertices = curpos_src = ALIGN8(dst_header->ptr_vertices - src_roomoffset); + uintptr_t ptr_dst_vertices = curpos_dst + dst_roomoffset; + + add_marker(curpos_src + src_roomoffset, curpos_dst + dst_roomoffset); + + uintptr_t vtx_end = dst_header->ptr_colours - src_roomoffset; + vtx_end = dst_header->ptr_colours == 0 ? infsize : vtx_end; + + while (curpos_src < vtx_end) { + struct vtx *src_vtx = (struct vtx*)(src_roomgfxdata + curpos_src); + struct vtx *dst_vtx = (struct vtx*)(dst + curpos_dst); + + dst_vtx->coord[0] = srctoh16(src_vtx->coord[0]); + dst_vtx->coord[1] = srctoh16(src_vtx->coord[1]); + dst_vtx->coord[2] = srctoh16(src_vtx->coord[2]); + + dst_vtx->flag = src_vtx->flag; + dst_vtx->color= src_vtx->color; + + dst_vtx->s = srctoh16(src_vtx->s); + dst_vtx->t = srctoh16(src_vtx->t); + + curpos_src += sizeof(struct vtx); + curpos_dst += sizeof(struct vtx); + } + + curpos_dst = ALIGN8(curpos_dst); + + // colors + uintptr_t ptr_src_colors = 0; + uintptr_t ptr_dst_colors = 0; + + if (dst_header->ptr_colours) { + ptr_src_colors = curpos_src = ALIGN8(dst_header->ptr_colours - src_roomoffset); + ptr_dst_colors = curpos_dst + dst_roomoffset; + + add_marker(curpos_src + src_roomoffset, curpos_dst + dst_roomoffset); + + uintptr_t col_end = numgdls > 0 != 0 ? gdls_addr[0] : infsize; + size_t col_len = col_end - curpos_src; + + memcpy(dst + curpos_dst, src_roomgfxdata + curpos_src, col_len); + curpos_src += col_len; + curpos_dst += col_len; + } + + // gdls + gbi_set_vtx(src_header->ptr_vertices, ptr_src_vertices); + gbi_set_segment(0x0e, dst_header->ptr_vertices); + + m_SizeGDLs = 0; + uintptr_t gdlstart = curpos_dst; + for (size_t i = 0; i < numgdls; i++) { + add_marker(gdls_addr[i] + src_roomoffset, curpos_dst + dst_roomoffset); + curpos_dst = gbi_convert_gdl(dst, curpos_dst, src_roomgfxdata, gdls_addr[i], 1); + } + m_SizeGDLs = curpos_dst - gdlstart; + + // relink ptrs: roomblocks + for (size_t i = 0; i < numblocks; i++) { + struct host_roomblock *block = (struct host_roomblock*)&ptr_dst_roomblocks[i]; + + relink_ptr(&block->ptr_next); + + if (block->type == BLOCK_LEAF) { + relink_ptr(&block->ptr_gdl); + uint32_t offset_vtx = block->ptr_vertices - ptr_src_vertices - src_roomoffset; + uint32_t offset_col = block->ptr_colours - ptr_src_colors - src_roomoffset; + + block->ptr_vertices = ptr_dst_vertices + offset_vtx; + block->ptr_colours = ptr_dst_colors + offset_col; + } + else { + relink_ptr(&block->ptr_gdl); // child + relink_ptr(&block->ptr_vertices); // coord + } + } + + // relink ptrs: header + relink_ptr(&dst_header->ptr_vertices); + relink_ptr(&dst_header->ptr_colours); + relink_ptr(&dst_header->ptr_opablocks); + relink_ptr(&dst_header->ptr_xlublocks); + + free(src_roomgfxdata); + return curpos_dst; } static uint32_t convert_section1(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, struct fileheader *n64_header) @@ -276,51 +544,67 @@ static uint32_t convert_section1(uint8_t *dst, uint32_t dstpos, uint8_t *src, ui // Convert primary struct host_primaryheader *host_primary_header = (struct host_primaryheader *) &dstbin[dstbinpos]; + struct n64_primaryheader *n64_primary_header = (struct n64_primaryheader *) &srcbin[srcbinpos]; srcbinpos += sizeof(struct n64_primaryheader); dstbinpos += sizeof(*host_primary_header); + uint32_t src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - 0x0f000000; + host_primary_header->unused1 = 0; host_primary_header->unused2 = 0; - host_primary_header->ptr_rooms = dstbinpos; + host_primary_header->ptr_rooms = dstbinpos + 0x0f000000; convert_primary_rooms(dstbin, &dstbinpos, srcbin, &srcbinpos); + + if (n64_primary_header->ptr_lights) { + host_primary_header->ptr_lights = dstbinpos + 0x0f000000; + srcbinpos = srctodst32(n64_primary_header->ptr_lights) - 0x0f000000; + convert_primary_lights(dstbin, &dstbinpos, srcbin, &srcbinpos, src_bgcmds); + } - host_primary_header->ptr_portals = dstbinpos; - convert_primary_portals(dstbin, &dstbinpos, srcbin, &srcbinpos); + host_primary_header->ptr_portals = dstbinpos + 0x0f000000; + srcbinpos = srctodst32(n64_primary_header->ptr_portals) - 0x0f000000; + uint32_t src_portalvtxs, dst_portalvtxs; + convert_primary_portals(dstbin, &dstbinpos, srcbin, &srcbinpos, &src_portalvtxs, &dst_portalvtxs); - host_primary_header->ptr_bgcmds = dstbinpos; - convert_primary_bgcmds(dstbin, &dstbinpos, srcbin, &srcbinpos); - - host_primary_header->ptr_lights = dstbinpos; - convert_primary_lights(dstbin, &dstbinpos, srcbin, &srcbinpos, infsize); + host_primary_header->ptr_bgcmds = dstbinpos + 0x0f000000; + srcbinpos = src_bgcmds; + convert_primary_bgcmds(dstbin, &dstbinpos, srcbin, &srcbinpos, dst_portalvtxs, src_portalvtxs); // Convert room gfxdata - uint32_t n64_primary_diff = n64_header->primary_infsize - n64_header->primary_cmpsize; - struct n64_room *n64_rooms = (struct n64_room *) &src[sizeof(*n64_header)]; - struct host_room *host_rooms = (struct host_room *) &dst[dstbinpos]; - - uint8_t *roomgfxbuf = calloc(1, 1024 * 1024); - uint8_t *allcmp = calloc(1, 1024 * 1024); - int roomgfxbufpos = 0; + uint32_t n64_primary_diff = srctoh32(n64_header->primary_infsize) - srctoh32(n64_header->primary_cmpsize) - 0xc; + struct n64_room *n64_rooms = (struct n64_room *) &srcbin[sizeof(struct n64_primaryheader)]; + struct host_room *host_rooms = (struct host_room *) &dstbin[sizeof(struct host_primaryheader)]; + + uint8_t *roomgfxbuf = calloc(1, (size_t)1024 * 1024); + uint8_t *allcmp = calloc(1, (size_t)1024 * 1024); int cmppos = 0; - //for (int i = 0; i < m_NumRooms; i++) { - // host_rooms[i].ptr_gfxdata = dstbinpos + cmppos; + host_rooms[0].ptr_gfxdata = 0; + for (int i = 1; i <= m_NumRooms; i++) { + host_rooms[i].ptr_gfxdata = dstbinpos + cmppos + 0x0f000000; - // srcpos = srctoh32(n64_rooms[i].ptr_gfxdata) - n64_primary_diff; - // roomgfxbufpos = convert_section1_roomgfxdata(roomgfxbuf, 0, src, srcpos); + if (i == m_NumRooms) break; - // size_t ziplen = 0; - // ret = rzip_deflate(&allcmp[cmppos], &ziplen, roomgfxbuf, roomgfxbufpos); + uint32_t gfxdatacompsize = srctoh32(n64_rooms[i + 1].ptr_gfxdata) - srctoh32(n64_rooms[i].ptr_gfxdata); + srcpos = srctoh32(n64_rooms[i].ptr_gfxdata) - n64_primary_diff - 0x0f000000; + uint32_t src_roomoffset = srctoh32(n64_rooms[i].ptr_gfxdata); + uint32_t roomgfxbufpos = convert_section1_roomgfxdata(roomgfxbuf, 0, src+srcpos, gfxdatacompsize, src_roomoffset, dstbinpos + cmppos); - // if (ret < 0) { - // fprintf(stderr, "Unable to compress BG roomgfxdata for room 0x%x: %d\n", i, ret); - // exit(EXIT_FAILURE); - // } + size_t ziplen = 0; + ret = rzip_deflate(&allcmp[cmppos], &ziplen, roomgfxbuf, roomgfxbufpos); + if (ret < 0) { + fprintf(stderr, "Unable to compress BG roomgfxdata for room 0x%x: %d\n", i, ret); + exit(EXIT_FAILURE); + } - // ziplen = ALIGN16(ziplen); - // cmppos += ziplen; - //} + ziplen = ALIGN16(ziplen); + cmppos += ziplen; + + m_AllocSizes[i - 1] = roomgfxbufpos + (ziplen > m_SizeGDLs ? ziplen*4 : m_SizeGDLs*4); + } + + host_rooms[m_NumRooms+1].ptr_gfxdata = 0; // Zip primary size_t ziplen = 0; @@ -392,7 +676,7 @@ static void convert_section3_allocsizes(uint8_t *dst, uint32_t *dstpos, uint8_t uint16_t *dst_sizes = (uint16_t *) &dst[*dstpos]; for (int i = 0; i < m_NumRooms; i++) { - dst_sizes[i] = m_AllocSizes[i]; + dst_sizes[i] = (m_AllocSizes[i] - 0x100) / 0x10; } *srcpos += sizeof(uint16_t) * (m_NumRooms - 1); @@ -465,11 +749,17 @@ void extract_file_bg(char *filename, uint32_t romoffset, size_t len) return; } } - return; + + if (strcmp(filename, "ob/ob_mid.seg") == 0) { + return; + } size_t dstlen = len * 2; uint8_t *dst = calloc(1, dstlen); uint32_t dstpos = 0; + m_NumPtrMarkers = 0; + m_SizeGDLs = 0; + gbi_reset(); printf("--------------------------------------------------------------------------------\n"); printf("-- %s\n", filename); @@ -489,6 +779,8 @@ void extract_file_bg(char *filename, uint32_t romoffset, size_t len) dstpos = convert_zipped_section(3, dst, dstpos, src, n64_section3_start + sizeof(*n64_section3header), n64_section3header); dstpos = ALIGN16(dstpos); + sysLogPrintf(LOG_NOTE, "%s %d %d %.3f", filename, len, dstpos, (f32)dstpos / len); + char outfilename[1024]; sprintf(outfilename, "%s/files/%s", g_OutPath, filename); diff --git a/port/pdextract/ext_file_model.c b/port/pdextract/ext_file_model.c index aef347484..3a91748c8 100644 --- a/port/pdextract/ext_file_model.c +++ b/port/pdextract/ext_file_model.c @@ -2,6 +2,12 @@ #include #include #include "common.h" +#include "system.h" + +#include + +#undef near +#undef far enum contenttype { /* 0*/ CT_MODELDEF, @@ -45,7 +51,7 @@ struct alignconfig m_AlignConfigs[] = { /* 2*/ { 4, 4 }, /* 3*/ { 8, 8 }, /* 4*/ { 4, 4 }, - /* 5*/ { 4, 8 }, + /* 5*/ { 8, 8 }, /* 6*/ { 8, 8 }, /* 7*/ { 4, 4 }, /* 8*/ { 4, 4 }, @@ -396,6 +402,8 @@ static void populate_markers(uint8_t *src) for (int i = 0; i < m_NumMarkers; i++) { struct marker *marker = &m_Markers[i]; void *src_thing = &src[marker->src_offset]; + int numvtx = 0; + uint32_t colstart = 0; switch (marker->type) { case CT_MODELDEF: @@ -439,9 +447,14 @@ static void populate_markers(uint8_t *src) break; case CT_RODATA_GUNDL: struct src_rodata_gundl *src_gundl = src_thing; + numvtx = srctoh16(src_gundl->numvertices); + colstart = srctoh32(src_gundl->ptr_vertices) + numvtx * 12; + colstart = ALIGN(colstart, m_AlignConfigs[marker->type].before); + set_marker(srctoh32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); set_marker(srctoh32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); set_marker(srctoh32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); + set_marker(colstart, CT_VTXCOL, marker->src_offset); break; case CT_RODATA_DISTANCE: struct src_rodata_distance *src_dist = src_thing; @@ -462,11 +475,18 @@ static void populate_markers(uint8_t *src) break; case CT_RODATA_STARGUNFIRE: struct src_rodata_stargunfire *src_stargunfire = src_thing; + numvtx = srctoh16(src_stargunfire->unk00); + set_marker(srctoh32(src_stargunfire->ptr_vertices), CT_VTXCOL, marker->src_offset); + set_marker(srctoh32(src_stargunfire->ptr_vertices) + numvtx * 12, CT_VTXCOL, marker->src_offset); set_marker(srctoh32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); break; case CT_RODATA_DL: struct src_rodata_dl *src_dl = src_thing; + numvtx = srctoh16(src_dl->numvertices); + colstart = srctoh32(src_dl->ptr_vertices) + numvtx * 12; + colstart = ALIGN(colstart, 8); + set_marker(srctoh32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); set_marker(srctoh32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); set_marker(srctoh32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); @@ -609,10 +629,7 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; } - gbi_set_vtx(src_vtx, dst_vtx); - gbi_set_segment(0x04, dst_vtx); - gbi_set_segment(0x05, 0); - dstpos = gbi_convert_gdl(dst, dstpos, src, marker->src_offset); + dstpos = gbi_convert_gdl(dst, dstpos, src, marker->src_offset, 0); break; case CT_RODATA_CHRINFO: struct generic_rodata_chrinfo *src_chrinfo = src_thing; @@ -803,6 +820,7 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) struct dst_texconfig *dst_texconfig = dst_thing; if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { dst_texconfig->ptr = htodst32(resolve_pointer(srctoh32(src_texconfig->ptr))); + gbi_add_tex_addr(srctoh32(src_texconfig->ptr), dst_texconfig->ptr); } break; case CT_PARTS: @@ -825,6 +843,17 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) dst_gundl->ptr_opagdl = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_opagdl))); dst_gundl->ptr_xlugdl = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_xlugdl))); dst_gundl->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_vertices))); + + gbi_convert_vtx(dst, dst_gundl->ptr_vertices & 0x00ffffff, dst_gundl->numvertices); + + gbi_set_vtx(srctoh32(src_gundl->ptr_vertices), dst_gundl->ptr_vertices); + gbi_set_segment(0x04, dst_gundl->ptr_vertices); + + gbi_gdl_rewrite_addrs(dst, dst_gundl->ptr_opagdl); + gbi_gdl_rewrite_addrs(dst, dst_gundl->ptr_xlugdl); + + if (dst_gundl->ptr_opagdl) dst_gundl->ptr_opagdl |= 1; + if (dst_gundl->ptr_xlugdl) dst_gundl->ptr_xlugdl |= 1; break; case CT_RODATA_DISTANCE: struct src_rodata_distance *src_dist = src_thing; @@ -841,6 +870,9 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) struct src_rodata_chrgunfire *src_chrgunfire = src_thing; struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; dst_chrgunfire->ptr_texture = htodst32(resolve_pointer(srctoh32(src_chrgunfire->ptr_texture))); + if ((srctoh32(dst_chrgunfire->ptr_texture) & 0xff000000) == 0x05000000) { + gbi_add_tex_addr(srctoh32(dst_chrgunfire->ptr_texture), dst_chrgunfire->ptr_texture); + } break; case CT_RODATA_TOGGLE: struct src_rodata_toggle *src_toggle = src_thing; @@ -852,6 +884,13 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; dst_stargunfire->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_stargunfire->ptr_vertices))); dst_stargunfire->ptr_gdl = htodst32(resolve_pointer(srctoh32(src_stargunfire->ptr_gdl))); + + gbi_convert_vtx(dst, dst_stargunfire->ptr_vertices & 0x00ffffff, dst_stargunfire->unk00); + + gbi_set_vtx(srctoh32(src_stargunfire->ptr_vertices), dst_stargunfire->ptr_vertices); + gbi_set_segment(0x04, dst_stargunfire->ptr_vertices); + gbi_gdl_rewrite_addrs(dst, dst_stargunfire->ptr_gdl); + if (dst_stargunfire->ptr_gdl) dst_stargunfire->ptr_gdl |= 1; break; case CT_RODATA_DL: struct src_rodata_dl *src_dl = src_thing; @@ -860,6 +899,16 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) dst_dl->ptr_xlugdl = htodst32(resolve_pointer(srctoh32(src_dl->ptr_xlugdl))); dst_dl->ptr_colours = htodst32(resolve_pointer(srctoh32(src_dl->ptr_colours))); dst_dl->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_dl->ptr_vertices))); + + gbi_convert_vtx(dst, dst_dl->ptr_vertices & 0x00ffffff, dst_dl->numvertices); + + gbi_set_vtx(srctoh32(src_dl->ptr_vertices), dst_dl->ptr_vertices); + gbi_set_segment(0x04, dst_dl->ptr_vertices); + gbi_gdl_rewrite_addrs(dst, dst_dl->ptr_opagdl); + gbi_gdl_rewrite_addrs(dst, dst_dl->ptr_xlugdl); + + if (dst_dl->ptr_opagdl) dst_dl->ptr_opagdl |= 1; + if (dst_dl->ptr_xlugdl) dst_dl->ptr_xlugdl |= 1; break; case CT_TEXDATA: case CT_VTXCOL: @@ -904,6 +953,7 @@ static int convert_model(uint8_t *dst, uint8_t *src, uint32_t srclen) void extract_file_model(char *filename, uint32_t romoffset, size_t len) { + gbi_reset(); // Unzip it size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); uint8_t *src = malloc(infsize); @@ -916,7 +966,7 @@ void extract_file_model(char *filename, uint32_t romoffset, size_t len) } // Convert it - uint8_t *dst = calloc(1, infsize * 4); + uint8_t *dst = calloc(1, infsize * 2); int dstpos = convert_model(dst, src, infsize); @@ -942,6 +992,8 @@ void extract_file_model(char *filename, uint32_t romoffset, size_t len) char outfilename[1024]; sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + sysLogPrintf(LOG_NOTE, "%s %d %d %.3f", filename, infsize, dstpos, (f32)dstpos/infsize); + FILE *fp = openfile(outfilename); fwrite(zipped, ziplen, 1, fp); fclose(fp); diff --git a/port/pdextract/gbi.c b/port/pdextract/gbi.c index a59f77871..64d541331 100644 --- a/port/pdextract/gbi.c +++ b/port/pdextract/gbi.c @@ -21,71 +21,69 @@ struct vtx { int16_t t; }; +struct texaddr { + uint32_t src; + uint32_t dst; +}; + uint32_t m_Segments[16]; -uint8_t m_Seen[1024]; uint32_t m_SrcVtxOffset; uint32_t m_DstVtxOffset; +struct texaddr m_TexAddrs[64]; +int m_NumTexAddr; + void gbi_reset(void) { for (int i = 0; i < ARRAYCOUNT(m_Segments); i++) { m_Segments[i] = 0; } - - for (int i = 0; i < ARRAYCOUNT(m_Seen); i++) { - m_Seen[i] = 0; - } - + m_SrcVtxOffset = 0; m_DstVtxOffset = 0; + m_NumTexAddr = 0; } void gbi_set_segment(int segment, uint32_t offset) { - m_Segments[segment] = offset; + m_Segments[segment] = offset & 0x00ffffff; } void gbi_set_vtx(uint32_t src_offset, uint32_t dst_offset) { - m_SrcVtxOffset = src_offset; - m_DstVtxOffset = dst_offset; + m_SrcVtxOffset = src_offset & 0x00ffffff; + m_DstVtxOffset = dst_offset & 0x00ffffff; } -static void gbi_convert_col(uint8_t *dst, uint32_t dstpos, int count) +void gbi_add_tex_addr(uint32_t src_offset, uint32_t dst_offset) { - for (int i = 0; i < count; i++) { - int index = dstpos / 4; + m_TexAddrs[m_NumTexAddr].src = src_offset & 0x00ffffff; + m_TexAddrs[m_NumTexAddr++].dst = dst_offset & 0x00ffffff; +} - if (!m_Seen[index]) { - uint32_t *col = (uint32_t *) &dst[dstpos]; - - *col = srctodst32(*col); - - m_Seen[index] = 1; - } - - dstpos += sizeof(uint32_t); +uint32_t gbi_find_tex_addr(uint32_t src_offset) +{ + for (int i = 0; i < m_NumTexAddr; i++) { + if (m_TexAddrs[i].src == src_offset) + return m_TexAddrs[i].dst; } + + return 0; } -static void gbi_convert_vtx(uint8_t *dst, uint32_t dstpos, int count) +void gbi_convert_vtx(uint8_t *dst, uint32_t offset, int count) { + if (!offset) return; + struct vtx* vtxs = (struct vtx*)(dst + offset); + for (int i = 0; i < count; i++) { - int index = dstpos / 4; + struct vtx* vtx = &vtxs[i]; - if (!m_Seen[index]) { - struct vtx *vtx = (struct vtx *) &dst[dstpos]; - - vtx->x = srctodst16(vtx->x); - vtx->y = srctodst16(vtx->y); - vtx->z = srctodst16(vtx->z); - vtx->s = srctodst16(vtx->s); - vtx->t = srctodst16(vtx->t); - - m_Seen[index] = 1; - } - - dstpos += 12; + vtx->x = srctodst16(vtx->x); + vtx->y = srctodst16(vtx->y); + vtx->z = srctodst16(vtx->z); + vtx->s = srctodst16(vtx->s); + vtx->t = srctodst16(vtx->t); } } @@ -94,93 +92,105 @@ static void gbi_convert_vtx(uint8_t *dst, uint32_t dstpos, int count) #define CMD_IS_COL(cmd) ((cmd & 0xff00000000000000) == 0x0700000000000000) #define CMD_IS_ENDDL(cmd) ((cmd & 0xff00000000000000) == 0xb800000000000000) #define CMD_IS_MOVEWORD(cmd) ((cmd & 0xff00000000000000) == 0xbc00000000000000) +#define CMD_IS_MOVEMEM(cmd) ((cmd & 0xff00000000000000) == 0x0300000000000000) +#define CMD_IS_MTX(cmd) ((cmd & 0xff00000000000000) == 0x0100000000000000) +#define CMD_IS_SETTIMG(cmd) ((cmd & 0xff00000000000000) == 0xfd00000000000000) +#define CMD_IS_SETZIMG(cmd) ((cmd & 0xff00000000000000) == 0xfe00000000000000) +#define CMD_IS_SETCIMG(cmd) ((cmd & 0xff00000000000000) == 0xff00000000000000) #define CMD_HAS_ADDR(cmd) CMD_IS_VTX(cmd) \ || CMD_IS_COL(cmd) \ - || CMD_IS_MOVEWORD(cmd) + || CMD_IS_MOVEWORD(cmd) \ + || CMD_IS_SETTIMG(cmd) -static void gbi_convert_vtx_by_cmd(uint64_t cmd, uint8_t *dst) -{ - uint8_t segment = cmd & 0xff000000; - uint8_t offset = cmd & 0x00ffffff; - uint32_t num_bytes = (cmd >> 32) & 0xffff; - int num_vertices = num_bytes / 12; - if (segment == 5) { - uint32_t dst_offset = offset - m_SrcVtxOffset + m_DstVtxOffset; - gbi_convert_vtx(dst, dst_offset, num_vertices); - } else { - gbi_convert_vtx(dst, m_Segments[segment] + offset, num_vertices); - } -} - -static void gbi_convert_col_by_cmd(uint64_t cmd, uint8_t *dst) -{ - uint8_t segment = cmd & 0xff000000; - uint8_t offset = cmd & 0x00ffffff; - uint32_t num_bytes = (cmd >> 32) & 0xffff; - int num_colours = num_bytes / 4; - - if (segment == 5) { - uint32_t dst_offset = offset - m_SrcVtxOffset + m_DstVtxOffset; - gbi_convert_col(dst, dst_offset, num_colours); - } else { - gbi_convert_col(dst, m_Segments[segment] + offset, num_colours); - } -} +#define CMD_IS_SEGMENTED(cmd) ( CMD_IS_MOVEMEM(cmd) \ + || CMD_IS_MTX(cmd) \ + || CMD_IS_VTX(cmd) \ + || CMD_IS_COL(cmd) \ + || CMD_IS_DL(cmd) \ + || CMD_IS_SETTIMG(cmd) \ + || CMD_IS_SETCIMG(cmd) \ + || CMD_IS_SETZIMG(cmd)) /** * Segment 5 is the start of the model file. The data in these files shifts * depending on the pointer size, so this function adjusts the offset accordingly. */ -static uint64_t gbi_rewrite_addr(uint64_t cmd) +static uint64_t gbi_rewrite_addr(uint64_t cmd, uint8_t opcode) { - uint8_t segment = cmd & 0xff000000; - uint8_t offset = cmd & 0x00ffffff; + uint8_t segment = (cmd & 0x0f000000) >> 24; + uint32_t offset = cmd & 0x00ffffff; if (segment == 5) { - if (offset < m_SrcVtxOffset) { - printf("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, m_SrcVtxOffset); - exit(EXIT_FAILURE); + if (opcode == 0xfd) { + offset = gbi_find_tex_addr(offset); } + else { + if (offset < m_SrcVtxOffset) { + printf("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, m_SrcVtxOffset); + exit(EXIT_FAILURE); + } - offset = offset - m_SrcVtxOffset + m_DstVtxOffset; + offset = offset - m_SrcVtxOffset + m_DstVtxOffset; + } } return (cmd & 0xffffffffff000000) | offset; } -uint32_t gbi_convert_gdl(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos) +void gbi_gdl_rewrite_addrs(uint8_t *dst, uint32_t offset) +{ + if (!offset) return; + + uint64_t *cmds = (uint64_t*)(dst + (offset & 0x00ffffff)); + if (!cmds) return; + + uint64_t cmd; + + do { + cmd = *cmds; + + if (CMD_HAS_ADDR((cmd << 32))) { + uint8_t opcode = (cmd >> 24) & 0xff; + cmds[1] = gbi_rewrite_addr(cmds[1], opcode); + } + + if (CMD_IS_SEGMENTED((cmd << 32))) { + cmds[1] |= 1; + } + + cmds += 2; + } while (!CMD_IS_ENDDL((cmd << 32))); +} + +uint32_t gbi_convert_gdl(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, int segment_cmds) { dstpos = ALIGN8(dstpos); - uint64_t *n64_cmd = (uint64_t *) &src[srcpos]; - uint64_t *host_cmd = (uint64_t *) &dst[dstpos]; + uint64_t *n64_cmd = (uint64_t*)&src[srcpos]; + uint64_t *host_cmd = (uint64_t*)&dst[dstpos]; uint64_t cmd; do { cmd = srctoh64(*n64_cmd); #if HOST_DWORDS_PER_CMD == 2 - if (CMD_HAS_ADDR(cmd)) { - cmd = gbi_rewrite_addr(cmd); - host_cmd[0] = htodst64(cmd & 0xffffffff00000000); - host_cmd[1] = htodst64(cmd & 0x00000000ffffffff); - } else { - host_cmd[0] = htodst64(cmd); - host_cmd[1] = 0; + host_cmd[0] = htodst64((cmd & 0xffffffff00000000) >> 32); + host_cmd[1] = htodst64(cmd & 0xffffffff); + + if (segment_cmds && CMD_IS_SEGMENTED(cmd)) { + host_cmd[1] |= 1; } #else host_cmd[0] = htodst64(cmd); -#endif - dstpos += sizeof(*host_cmd) * HOST_DWORDS_PER_CMD; - if (CMD_IS_VTX(cmd)) { - gbi_convert_vtx_by_cmd(cmd, dst); - } else if (CMD_IS_COL(cmd)) { - gbi_convert_col_by_cmd(cmd, dst); + if (segment_cmds && CMD_IS_SEGMENTED(cmd)) { + host_cmd[0] |= 1; } +#endif + dstpos += sizeof(*host_cmd) * HOST_DWORDS_PER_CMD; host_cmd += HOST_DWORDS_PER_CMD; n64_cmd++; } while (!CMD_IS_ENDDL(cmd)); From 2e2dbfb5785de5ef60e0ba9d13858f19b39a4818 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Tue, 30 Jul 2024 17:56:15 +0800 Subject: [PATCH 11/81] portx64: pd-extract: setups jesus didn't help in this off-by-one error hell --- port/pdextract/ext_setups.c | 1284 ++++++++++++++++++++++++++++++++++ port/pdextract/setups_decl.h | 644 +++++++++++++++++ 2 files changed, 1928 insertions(+) create mode 100644 port/pdextract/ext_setups.c create mode 100644 port/pdextract/setups_decl.h diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c new file mode 100644 index 000000000..ea8745e72 --- /dev/null +++ b/port/pdextract/ext_setups.c @@ -0,0 +1,1284 @@ +#include +#include +#include + +#include "common.h" +#include "system.h" +#include "assert.h" +#include "setups_decl.h" + +#include "types.h" + +static inline f32 convF32(f32 *dst, f32 src) { *(u32*)dst = srctoh32(*(u32*)&src); } +static inline u32 convU32(u32 *dst, u32 src) { *dst = srctoh32(src); } +static inline s32 convS32(s32 *dst, s32 src) { *dst = srctoh32(src); } +static inline u16 convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } +static inline s16 convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } +static inline u8 cpyByte(u8 *dst, u8 src) { *dst = src; } +static inline void* convPtr(void** dst, u32 src) { *dst = srctoh32(src); } +static inline struct coord convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } +static u32 convUnk(void* x, u32 y) { __debugbreak(); } + +#define PD_CONV_VAL(dst, src) _Generic((dst), \ + f32: convF32, \ + u32: convU32, \ + s32: convS32, \ + u16: convU16, \ + s16: convS16, \ + u8: cpyByte, \ + s8: cpyByte, \ + struct coord: convCoord, \ + default: convUnk \ +)(&dst, src) + +#define PD_CONV_ARRAY(dst, src) { for (int i = 0; i < ARRAYCOUNT(dst); i++) PD_CONV_VAL(dst[i], src[i]); } +#define PD_CONV_ARRAY2D(dst, src) { \ + for (int i = 0; i < ARRAYCOUNT(dst); i++) \ + for (int j = 0; j < ARRAYCOUNT(dst); j++) PD_CONV_VAL(dst[i][j], src[i][j]); \ +} + +#define PD_CONV_PTR(dst, src) dst = srctoh32(src) + +u32 obj_size(struct n64_defaultobj *obj) +{ + switch (obj->type) { + case OBJTYPE_CHR: return sizeof(struct n64_packedchr) / sizeof(u32); + case OBJTYPE_DOOR: return sizeof(struct n64_doorobj) / sizeof(u32); + case OBJTYPE_DOORSCALE: return sizeof(struct n64_doorscaleobj) / sizeof(u32); + case OBJTYPE_BASIC: return sizeof(struct n64_defaultobj) / sizeof(u32); + case OBJTYPE_DEBRIS: return sizeof(struct n64_debrisobj) / sizeof(u32); + case OBJTYPE_GLASS: return sizeof(struct n64_glassobj) / sizeof(u32); + case OBJTYPE_TINTEDGLASS: return sizeof(struct n64_tintedglassobj) / sizeof(u32); + case OBJTYPE_SAFE: return sizeof(struct n64_safeobj) / sizeof(u32); + case OBJTYPE_GASBOTTLE: return sizeof(struct gasbottleobj) / sizeof(u32); + case OBJTYPE_KEY: return sizeof(struct n64_keyobj) / sizeof(u32); + case OBJTYPE_ALARM: return sizeof(struct n64_alarmobj) / sizeof(u32); + case OBJTYPE_CCTV: return sizeof(struct n64_cctvobj) / sizeof(u32); + case OBJTYPE_AMMOCRATE: return sizeof(struct n64_ammocrateobj) / sizeof(u32); + case OBJTYPE_WEAPON: return sizeof(struct n64_weaponobj) / sizeof(u32); + case OBJTYPE_SINGLEMONITOR: return sizeof(struct n64_singlemonitorobj) / sizeof(u32); + case OBJTYPE_MULTIMONITOR: return sizeof(struct n64_multimonitorobj) / sizeof(u32); + case OBJTYPE_HANGINGMONITORS: return sizeof(struct n64_hangingmonitorsobj) / sizeof(u32); + case OBJTYPE_AUTOGUN: return sizeof(struct n64_autogunobj) / sizeof(u32); + case OBJTYPE_LINKGUNS: return sizeof(struct linkgunsobj) / sizeof(u32); + case OBJTYPE_HAT: return sizeof(struct n64_hatobj) / sizeof(u32); + case OBJTYPE_GRENADEPROB: return sizeof(struct grenadeprobobj) / sizeof(u32); + case OBJTYPE_LINKLIFTDOOR: return sizeof(struct n64_linkliftdoorobj) / sizeof(u32); + case OBJTYPE_SAFEITEM: return sizeof(struct n64_safeitemobj) / sizeof(u32); + case OBJTYPE_MULTIAMMOCRATE: return sizeof(struct n64_multiammocrateobj) / sizeof(u32); + case OBJTYPE_SHIELD: return sizeof(struct n64_shieldobj) / sizeof(u32); + case OBJTYPE_TAG: return sizeof(struct n64_tag) / sizeof(u32); + case OBJTYPE_RENAMEOBJ: return sizeof(struct n64_textoverride) / sizeof(u32); + case OBJTYPE_BEGINOBJECTIVE: return sizeof(struct n64_objective) / sizeof(u32); + case OBJTYPE_ENDOBJECTIVE: return 1; + case OBJECTIVETYPE_DESTROYOBJ: return 2; + case OBJECTIVETYPE_COMPFLAGS: return 2; + case OBJECTIVETYPE_FAILFLAGS: return 2; + case OBJECTIVETYPE_COLLECTOBJ: return 2; + case OBJECTIVETYPE_THROWOBJ: return 2; + case OBJECTIVETYPE_HOLOGRAPH: return sizeof(struct n64_criteria_holograph) / sizeof(u32); + case OBJECTIVETYPE_1F: return 1; + case OBJECTIVETYPE_ENTERROOM: return sizeof(struct n64_criteria_roomentered) / sizeof(u32); + case OBJECTIVETYPE_THROWINROOM: return sizeof(struct n64_criteria_throwinroom) / sizeof(u32); + case OBJTYPE_22: return 1; + case OBJTYPE_BRIEFING: return sizeof(struct n64_briefingobj) / sizeof(u32); + case OBJTYPE_PADLOCKEDDOOR: return sizeof(struct n64_padlockeddoorobj) / sizeof(u32); + case OBJTYPE_TRUCK: return sizeof(struct n64_truckobj) / sizeof(u32); + case OBJTYPE_HELI: return sizeof(struct n64_heliobj) / sizeof(u32); + case OBJTYPE_TANK: return 32; + case OBJTYPE_CAMERAPOS: return sizeof(struct n64_cameraposobj) / sizeof(u32); + case OBJTYPE_LIFT: return sizeof(struct n64_liftobj) / sizeof(u32); + case OBJTYPE_CONDITIONALSCENERY: return sizeof(struct n64_linksceneryobj) / sizeof(u32); + case OBJTYPE_BLOCKEDPATH: return sizeof(struct n64_blockedpathobj) / sizeof(u32); + case OBJTYPE_HOVERBIKE: return sizeof(struct n64_hoverbikeobj) / sizeof(u32); + case OBJTYPE_HOVERPROP: return sizeof(struct n64_hoverpropobj) / sizeof(u32); + case OBJTYPE_FAN: return sizeof(struct n64_fanobj) / sizeof(u32); + case OBJTYPE_HOVERCAR: return sizeof(struct n64_hovercarobj) / sizeof(u32); + case OBJTYPE_CHOPPER: return sizeof(struct n64_chopperobj) / sizeof(u32); + case OBJTYPE_PADEFFECT: return sizeof(struct padeffectobj) / sizeof(u32); + case OBJTYPE_MINE: return sizeof(struct n64_weaponobj) / sizeof(u32); + case OBJTYPE_ESCASTEP: return sizeof(struct n64_escalatorobj) / sizeof(u32); + } + + return 1; +} + + +void conv_tvscreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) +{ + PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist); + PD_CONV_VAL(dstobj->offset, srcobj->offset); + PD_CONV_VAL(dstobj->pause60, srcobj->pause60); + PD_CONV_PTR(dstobj->tconfig, srcobj->ptr_tconfig); + PD_CONV_VAL(dstobj->rot, srcobj->rot); + PD_CONV_VAL(dstobj->xscale, srcobj->xscale); + PD_CONV_VAL(dstobj->xscalefrac, srcobj->xscalefrac); + PD_CONV_VAL(dstobj->xscaleinc, srcobj->xscaleinc); + PD_CONV_VAL(dstobj->xscaleold, srcobj->xscaleold); + PD_CONV_VAL(dstobj->xscalenew, srcobj->xscalenew); + PD_CONV_VAL(dstobj->yscale, srcobj->yscale); + PD_CONV_VAL(dstobj->yscalefrac, srcobj->yscalefrac); + PD_CONV_VAL(dstobj->yscaleinc, srcobj->yscaleinc); + PD_CONV_VAL(dstobj->yscaleold, srcobj->yscaleold); + PD_CONV_VAL(dstobj->yscalenew, srcobj->yscalenew); + PD_CONV_VAL(dstobj->xmid, srcobj->xmid); + PD_CONV_VAL(dstobj->xmidfrac, srcobj->xmidfrac); + PD_CONV_VAL(dstobj->xmidinc, srcobj->xmidinc); + PD_CONV_VAL(dstobj->xmidold, srcobj->xmidold); + PD_CONV_VAL(dstobj->xmidnew, srcobj->xmidnew); + PD_CONV_VAL(dstobj->ymid, srcobj->ymid); + PD_CONV_VAL(dstobj->ymidfrac, srcobj->ymidfrac); + PD_CONV_VAL(dstobj->ymidinc, srcobj->ymidinc); + PD_CONV_VAL(dstobj->ymidold, srcobj->ymidold); + PD_CONV_VAL(dstobj->ymidnew, srcobj->ymidnew); + PD_CONV_VAL(dstobj->red, srcobj->red); + PD_CONV_VAL(dstobj->redold, srcobj->redold); + PD_CONV_VAL(dstobj->rednew, srcobj->rednew); + PD_CONV_VAL(dstobj->green, srcobj->green); + PD_CONV_VAL(dstobj->greenold, srcobj->greenold); + PD_CONV_VAL(dstobj->greennew, srcobj->greennew); + PD_CONV_VAL(dstobj->blue, srcobj->blue); + PD_CONV_VAL(dstobj->blueold, srcobj->blueold); + PD_CONV_VAL(dstobj->bluenew, srcobj->bluenew); + PD_CONV_VAL(dstobj->alpha, srcobj->alpha); + PD_CONV_VAL(dstobj->alphaold, srcobj->alphaold); + PD_CONV_VAL(dstobj->alphanew, srcobj->alphanew); + PD_CONV_VAL(dstobj->colfrac, srcobj->colfrac); + PD_CONV_VAL(dstobj->colinc, srcobj->colinc); +} + +void conv_default_obj_hdr(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) +{ + PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); + + /* 'header' is like this inside a u32: + u16 unk00_1, + u8 unk00_2, + u8 type, + */ + u16 *dst_unk00_1 = (u16*)&dstobj->extrascale; + u8 *dst_unk00_2 = (u8*)(dst_unk00_1 + 1); + + u16 *src_unk00_1 = (u16*)&srcobj->extrascale; + u8 *src_unk00_2 = (u8*)(src_unk00_1 + 1); + + *dst_unk00_1 = srctoh16(*src_unk00_1); + dst_unk00_2[0] = src_unk00_2[0]; + dst_unk00_2[1] = src_unk00_2[1]; +} + +void conv_default_obj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) +{ + PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); + PD_CONV_VAL(dstobj->hidden2, srcobj->hidden2); + PD_CONV_VAL(dstobj->type, srcobj->type); + PD_CONV_VAL(dstobj->modelnum, srcobj->modelnum); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->flags2, srcobj->flags2); + PD_CONV_VAL(dstobj->flags3, srcobj->flags3); + PD_CONV_PTR(dstobj->prop, srcobj->ptr_prop); + PD_CONV_PTR(dstobj->model, srcobj->ptr_model); + PD_CONV_ARRAY2D(dstobj->realrot, srcobj->realrot); + PD_CONV_VAL(dstobj->hidden, srcobj->hidden); + PD_CONV_PTR(dstobj->unkgeo, srcobj->ptr_unkgeo); + PD_CONV_PTR(dstobj->embedment, srcobj->ptr_embedment); + PD_CONV_VAL(dstobj->damage, srcobj->damage); + PD_CONV_VAL(dstobj->maxdamage, srcobj->maxdamage); + PD_CONV_ARRAY(dstobj->shadecol, srcobj->shadecol); + PD_CONV_ARRAY(dstobj->nextcol, srcobj->nextcol); + PD_CONV_VAL(dstobj->floorcol, srcobj->floorcol); + PD_CONV_VAL(dstobj->geocount, srcobj->geocount); +} + +u32 convert_props(u8* dst, u8* src) +{ + u8* start = dst; + struct n64_defaultobj* cmd = (struct n64_defaultobj*)src; + + int i = 0; + u8 type = cmd->type; + + while (type != OBJTYPE_END) { + //sysLogPrintf(LOG_NOTE, "#%03d obj 0x%02x (%s)", ++i, type, objName(cmd)); + switch (type) { + case OBJTYPE_DOOR: + { + struct n64_doorobj* srcobj = (struct n64_doorobj*)cmd; + struct doorobj* dstobj = (struct doorobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->maxfrac, srcobj->maxfrac); + PD_CONV_VAL(dstobj->perimfrac, srcobj->perimfrac); + PD_CONV_VAL(dstobj->accel, srcobj->accel); + PD_CONV_VAL(dstobj->decel, srcobj->decel); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->doorflags, srcobj->doorflags); + PD_CONV_VAL(dstobj->doortype, srcobj->doortype); + PD_CONV_VAL(dstobj->keyflags, srcobj->keyflags); + PD_CONV_VAL(dstobj->autoclosetime, srcobj->autoclosetime); + PD_CONV_VAL(dstobj->frac, srcobj->frac); + PD_CONV_VAL(dstobj->fracspeed, srcobj->fracspeed); + PD_CONV_VAL(dstobj->mode, srcobj->mode); + PD_CONV_VAL(dstobj->glasshits, srcobj->glasshits); + PD_CONV_VAL(dstobj->fadealpha, srcobj->fadealpha); + PD_CONV_VAL(dstobj->xludist, srcobj->xludist); + PD_CONV_VAL(dstobj->opadist, srcobj->opadist); + PD_CONV_VAL(dstobj->startpos, srcobj->startpos); + PD_CONV_ARRAY2D(dstobj->mtx98, srcobj->mtx98); + PD_CONV_PTR(dstobj->sibling, srcobj->ptr_sibling); + PD_CONV_VAL(dstobj->lastopen60, srcobj->lastopen60); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); + PD_CONV_VAL(dstobj->fadetime60, srcobj->fadetime60); + PD_CONV_VAL(dstobj->lastcalc60, srcobj->lastcalc60); + PD_CONV_VAL(dstobj->laserfade, srcobj->laserfade); + PD_CONV_ARRAY(dstobj->unusedmaybe, srcobj->unusedmaybe); + PD_CONV_ARRAY(dstobj->shadeinfo1, srcobj->shadeinfo1); + PD_CONV_ARRAY(dstobj->shadeinfo2, srcobj->shadeinfo2); + + PD_CONV_VAL(dstobj->actual1, srcobj->actual1); + PD_CONV_VAL(dstobj->actual2, srcobj->actual2); + PD_CONV_VAL(dstobj->extra1, srcobj->extra1); + PD_CONV_VAL(dstobj->extra2, srcobj->extra2); + + dst += sizeof(struct doorobj); + break; + } + case OBJTYPE_DOORSCALE: + { + struct n64_doorscaleobj* srcobj = (struct n64_doorscaleobj*)cmd; + struct doorscaleobj* dstobj = (struct doorscaleobj*)dst; + + dstobj->unk00 = htobe32(srcobj->unk00); + PD_CONV_VAL(dstobj->scale, srcobj->scale); + + dst += sizeof(struct doorscaleobj); + break; + } + case OBJTYPE_BASIC: + case OBJTYPE_HANGINGMONITORS: + case OBJTYPE_DEBRIS: + case OBJTYPE_HAT: + case OBJTYPE_ALARM: + { + struct n64_defaultobj* srcobj = (struct n64_defaultobj*)cmd; + struct defaultobj* dstobj = (struct defaultobj*)dst; + + conv_default_obj(dstobj, cmd); + + dst += sizeof(struct defaultobj); + break; + } + case OBJTYPE_KEY: + { + struct n64_keyobj* srcobj = (struct n64_keyobj*)cmd; + struct keyobj* dstobj = (struct keyobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->keyflags, srcobj->keyflags); + + dst += sizeof(struct keyobj); + src += sizeof(struct n64_keyobj); + break; + } + case OBJTYPE_CCTV: + { + struct n64_cctvobj* srcobj = (struct n64_cctvobj*)cmd; + struct cctvobj* dstobj = (struct cctvobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->lookatpadnum, srcobj->lookatpadnum); + PD_CONV_VAL(dstobj->toleft, srcobj->toleft); + PD_CONV_VAL(dstobj->yzero, srcobj->yzero); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yleft, srcobj->yleft); + PD_CONV_VAL(dstobj->yright, srcobj->yright); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->ymaxspeed, srcobj->ymaxspeed); + PD_CONV_VAL(dstobj->seebondtime60, srcobj->seebondtime60); + PD_CONV_VAL(dstobj->maxdist, srcobj->maxdist); + PD_CONV_VAL(dstobj->xzero, srcobj->xzero); + + dst += sizeof(struct cctvobj); + break; + } + case OBJTYPE_AMMOCRATE: + { + struct n64_ammocrateobj* srcobj = (struct n64_ammocrateobj*)cmd; + struct ammocrateobj* dstobj = (struct ammocrateobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->ammotype, srcobj->ammotype); + + dst += sizeof(struct ammocrateobj); + break; + } + case OBJTYPE_WEAPON: + case OBJTYPE_MINE: + { + struct n64_weaponobj* srcobj = (struct n64_weaponobj*)cmd; + struct weaponobj* dstobj = (struct weaponobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->weaponnum, srcobj->weaponnum); + PD_CONV_VAL(dstobj->unk5d, srcobj->unk5d); + PD_CONV_VAL(dstobj->unk5e, srcobj->unk5e); + PD_CONV_VAL(dstobj->gunfunc, srcobj->gunfunc); + + PD_CONV_VAL(dstobj->fadeouttimer60, srcobj->fadeouttimer60); + PD_CONV_VAL(dstobj->dualweaponnum, srcobj->dualweaponnum); + + PD_CONV_VAL(dstobj->team, srcobj->team); + + PD_CONV_PTR(dstobj->dualweapon, srcobj->ptr_dualweapon); + + dst += sizeof(struct weaponobj); + break; + } + case OBJTYPE_CHR: + { + struct n64_packedchr* srcobj = (struct n64_packedchr*)cmd; + struct packedchr* dstobj = (struct packedchr*)dst; + + PD_CONV_VAL(dstobj->chrindex, srcobj->chrindex); + PD_CONV_VAL(dstobj->unk02, srcobj->unk02); + PD_CONV_VAL(dstobj->typenum, srcobj->typenum); + PD_CONV_VAL(dstobj->spawnflags, srcobj->spawnflags); + PD_CONV_VAL(dstobj->chrnum, srcobj->chrnum); + PD_CONV_VAL(dstobj->padnum, srcobj->padnum); + PD_CONV_VAL(dstobj->bodynum, srcobj->bodynum); + PD_CONV_VAL(dstobj->headnum, srcobj->headnum); + PD_CONV_VAL(dstobj->ailistnum, srcobj->ailistnum); + PD_CONV_VAL(dstobj->padpreset, srcobj->padpreset); + PD_CONV_VAL(dstobj->chrpreset, srcobj->chrpreset); + PD_CONV_VAL(dstobj->hearscale, srcobj->hearscale); + PD_CONV_VAL(dstobj->viewdist, srcobj->viewdist); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->flags2, srcobj->flags2); + PD_CONV_VAL(dstobj->team, srcobj->team); + PD_CONV_VAL(dstobj->squadron, srcobj->squadron); + PD_CONV_VAL(dstobj->chair, srcobj->chair); + PD_CONV_VAL(dstobj->convtalk, srcobj->convtalk); + PD_CONV_VAL(dstobj->tude, srcobj->tude); + PD_CONV_VAL(dstobj->naturalanim, srcobj->naturalanim); + PD_CONV_VAL(dstobj->yvisang, srcobj->yvisang); + PD_CONV_VAL(dstobj->teamscandist, srcobj->teamscandist); + + dst += sizeof(struct packedchr); + break; + } + case OBJTYPE_SINGLEMONITOR: + { + struct n64_singlemonitorobj* srcobj = (struct n64_singlemonitorobj*)cmd; + struct singlemonitorobj* dstobj = (struct singlemonitorobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + conv_tvscreen(&dstobj->screen, &srcobj->screen); + + PD_CONV_VAL(dstobj->owneroffset, srcobj->owneroffset); + PD_CONV_VAL(dstobj->ownerpart, srcobj->ownerpart); + PD_CONV_VAL(dstobj->imagenum, srcobj->imagenum); + + dst += sizeof(struct singlemonitorobj); + break; + } + case OBJTYPE_MULTIMONITOR: + { + struct n64_multimonitorobj* srcobj = (struct n64_multimonitorobj*)cmd; + struct multimonitorobj* dstobj = (struct multimonitorobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + for (size_t i = 0; i < 4; i++) + conv_tvscreen(&dstobj->screens[i], &srcobj->screens[i]); + + PD_CONV_ARRAY(dstobj->imagenums, srcobj->imagenums); + dst += sizeof(struct multimonitorobj); + break; + } + case OBJTYPE_AUTOGUN: + { + struct n64_autogunobj* srcobj = (struct n64_autogunobj*)cmd; + struct autogunobj* dstobj = (struct autogunobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->targetpad, srcobj->targetpad); + PD_CONV_VAL(dstobj->firing, srcobj->firing); + PD_CONV_VAL(dstobj->firecount, srcobj->firecount); + PD_CONV_VAL(dstobj->yzero, srcobj->yzero); + PD_CONV_VAL(dstobj->ymaxleft, srcobj->ymaxleft); + PD_CONV_VAL(dstobj->ymaxright, srcobj->ymaxright); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->xzero, srcobj->xzero); + PD_CONV_VAL(dstobj->xrot, srcobj->xrot); + PD_CONV_VAL(dstobj->xspeed, srcobj->xspeed); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->aimdist, srcobj->aimdist); + PD_CONV_VAL(dstobj->barrelspeed, srcobj->barrelspeed); + PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); + PD_CONV_VAL(dstobj->lastseebond60, srcobj->lastseebond60); + PD_CONV_VAL(dstobj->lastaimbond60, srcobj->lastaimbond60); + PD_CONV_VAL(dstobj->allowsoundframe, srcobj->allowsoundframe); + PD_CONV_PTR(dstobj->beam, srcobj->ptr_beam); + PD_CONV_VAL(dstobj->shotbondsum, srcobj->shotbondsum); + PD_CONV_PTR(dstobj->target, srcobj->ptr_target); + PD_CONV_VAL(dstobj->targetteam, srcobj->targetteam); + PD_CONV_VAL(dstobj->ammoquantity, srcobj->ammoquantity); + PD_CONV_VAL(dstobj->nextchrtest, srcobj->nextchrtest); + + dst += sizeof(struct autogunobj); + break; + } + case OBJTYPE_LINKGUNS: + { + struct n64_linkgunsobj* srcobj = (struct n64_linkgunsobj*)cmd; + struct linkgunsobj* dstobj = (struct linkgunsobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->offset1, srcobj->offset1); + PD_CONV_VAL(dstobj->offset2, srcobj->offset2); + + dst += sizeof(struct linkgunsobj); + break; + } + case OBJTYPE_GRENADEPROB: + { + struct n64_grenadeprobobj* srcobj = (struct n64_grenadeprobobj*)cmd; + struct grenadeprobobj* dstobj = (struct grenadeprobobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->chrnum, srcobj->chrnum); + PD_CONV_VAL(dstobj->probability, srcobj->probability); + + dst += sizeof(struct grenadeprobobj); + break; + } + case OBJTYPE_LINKLIFTDOOR: + { + struct n64_linkliftdoorobj* srcobj = (struct n64_linkliftdoorobj*)cmd; + struct linkliftdoorobj* dstobj = (struct linkliftdoorobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->lift, srcobj->ptr_lift); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_VAL(dstobj->stopnum, srcobj->stopnum); + + dst += sizeof(struct linkliftdoorobj); + break; + } + case OBJTYPE_MULTIAMMOCRATE: + { + struct n64_multiammocrateobj* srcobj = (struct n64_multiammocrateobj*)cmd; + struct multiammocrateobj* dstobj = (struct multiammocrateobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + for (size_t i = 0; i < 19; i++) { + PD_CONV_VAL(dstobj->slots[i].modelnum, srcobj->slots[i].modelnum); + PD_CONV_VAL(dstobj->slots[i].quantity, srcobj->slots[i].quantity); + } + + dst += sizeof(struct multiammocrateobj); + break; + } + case OBJTYPE_SHIELD: + { + struct n64_shieldobj* srcobj = (struct n64_shieldobj*)cmd; + struct shieldobj* dstobj = (struct shieldobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->initialamount, srcobj->initialamount); + PD_CONV_VAL(dstobj->amount, srcobj->amount); + PD_CONV_VAL(dstobj->unk64, srcobj->unk64); + + dst += sizeof(struct shieldobj); + break; + } + case OBJTYPE_TAG: + { + struct n64_tag* srcobj = (struct n64_tag*)cmd; + struct tag* dstobj = (struct tag*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->tagnum, srcobj->tagnum); + PD_CONV_VAL(dstobj->cmdoffset, srcobj->cmdoffset); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + + dst += sizeof(struct tag); + break; + } + case OBJTYPE_BEGINOBJECTIVE: + { + struct n64_objective* srcobj = (struct n64_objective*)cmd; + struct objective* dstobj = (struct objective*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->index, srcobj->index); + PD_CONV_VAL(dstobj->text, srcobj->text); + PD_CONV_VAL(dstobj->unk0c, srcobj->unk0c); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->difficulties, srcobj->difficulties); + + dst += sizeof(struct objective); + break; + } + case OBJTYPE_ENDOBJECTIVE: + case OBJECTIVETYPE_1F: + case OBJTYPE_22: + case OBJTYPE_GASBOTTLE: + case OBJTYPE_29: + case OBJTYPE_SAFE: + { + struct n64_stdobjective* srcobj = (struct n64_stdobjective*)cmd; + struct n64_stdobjective* dstobj = (struct n64_stdobjective*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + + dst += sizeof(struct n64_stdobjective); + break; + } + case OBJECTIVETYPE_DESTROYOBJ: + case OBJECTIVETYPE_COMPFLAGS: + case OBJECTIVETYPE_FAILFLAGS: + case OBJECTIVETYPE_COLLECTOBJ: + case OBJECTIVETYPE_THROWOBJ: + { + struct n64_objectivecmd* srcobj = (struct n64_objectivecmd*)cmd; + struct n64_objectivecmd* dstobj = (struct n64_objectivecmd*)dst; + + PD_CONV_ARRAY(dstobj->cmd0, srcobj->cmd0); + PD_CONV_VAL(dstobj->cmd1, srcobj->cmd1); + + dst += sizeof(struct n64_objectivecmd); + break; + } + case OBJECTIVETYPE_HOLOGRAPH: + { + struct n64_criteria_holograph* srcobj = (struct n64_criteria_holograph*)cmd; + struct criteria_holograph* dstobj = (struct criteria_holograph*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->obj, srcobj->obj); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_holograph); + break; + } + case OBJECTIVETYPE_ENTERROOM: + { + struct n64_criteria_roomentered* srcobj = (struct n64_criteria_roomentered*)cmd; + struct criteria_roomentered* dstobj = (struct criteria_roomentered*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_roomentered); + break; + } + case OBJECTIVETYPE_THROWINROOM: + { + struct n64_criteria_throwinroom* srcobj = (struct n64_criteria_throwinroom*)cmd; + struct criteria_throwinroom* dstobj = (struct criteria_throwinroom*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_throwinroom); + break; + } + case OBJTYPE_BRIEFING: + { + struct n64_briefingobj* srcobj = (struct n64_briefingobj*)cmd; + struct briefingobj* dstobj = (struct briefingobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->type, srcobj->type); + PD_CONV_VAL(dstobj->text, srcobj->text); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct briefingobj); + break; + } + case OBJTYPE_RENAMEOBJ: + { + struct n64_textoverride* srcobj = (struct n64_textoverride*)cmd; + struct textoverride* dstobj = (struct textoverride*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->objoffset, srcobj->objoffset); + PD_CONV_VAL(dstobj->weapon, srcobj->weapon); + PD_CONV_VAL(dstobj->obtaintext, srcobj->obtaintext); + PD_CONV_VAL(dstobj->ownertext, srcobj->ownertext); + PD_CONV_VAL(dstobj->inventorytext, srcobj->inventorytext); + PD_CONV_VAL(dstobj->inventory2text, srcobj->inventory2text); + PD_CONV_VAL(dstobj->pickuptext, srcobj->pickuptext); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + + dst += sizeof(struct textoverride); + break; + } + case OBJTYPE_PADLOCKEDDOOR: + { + struct n64_padlockeddoorobj* srcobj = (struct n64_padlockeddoorobj*)cmd; + struct padlockeddoorobj* dstobj = (struct padlockeddoorobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->lock, srcobj->ptr_lock); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct padlockeddoorobj); + break; + } + case OBJTYPE_TRUCK: + { + struct n64_truckobj* srcobj = (struct n64_truckobj*)cmd; + struct truckobj* dstobj = (struct truckobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->wheelxrot, srcobj->wheelxrot); + PD_CONV_VAL(dstobj->wheelyrot, srcobj->wheelyrot); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + + dst += sizeof(struct truckobj); + break; + } + case OBJTYPE_HELI: + { + struct n64_heliobj* srcobj = (struct n64_heliobj*)cmd; + struct heliobj* dstobj = (struct heliobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->rotoryrot, srcobj->rotoryrot); + PD_CONV_VAL(dstobj->rotoryspeed, srcobj->rotoryspeed); + PD_CONV_VAL(dstobj->rotoryspeedaim, srcobj->rotoryspeedaim); + PD_CONV_VAL(dstobj->rotoryspeedtime, srcobj->rotoryspeedtime); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + + dst += sizeof(struct heliobj); + break; + } + case OBJTYPE_GLASS: + { + struct n64_glassobj* srcobj = (struct n64_glassobj*)cmd; + struct glassobj* dstobj = (struct glassobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + + dst += sizeof(struct glassobj); + break; + } + case OBJTYPE_SAFEITEM: + { + struct n64_safeitemobj* srcobj = (struct n64_safeitemobj*)cmd; + struct safeitemobj* dstobj = (struct safeitemobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->item, srcobj->ptr_item); + PD_CONV_PTR(dstobj->safe, srcobj->ptr_safe); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct safeitemobj); + break; + } + case OBJTYPE_TANK: + { + dst += sizeof(struct n64_tankobj); + break; + } + case OBJTYPE_CAMERAPOS: + { + struct n64_cameraposobj* srcobj = (struct n64_cameraposobj*)cmd; + struct cameraposobj* dstobj = (struct cameraposobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->x, srcobj->x); + PD_CONV_VAL(dstobj->y, srcobj->y); + PD_CONV_VAL(dstobj->z, srcobj->z); + PD_CONV_VAL(dstobj->theta, srcobj->theta); + PD_CONV_VAL(dstobj->verta, srcobj->verta); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + + dst += sizeof(struct cameraposobj); + break; + } + case OBJTYPE_TINTEDGLASS: + { + struct n64_tintedglassobj* srcobj = (struct n64_tintedglassobj*)cmd; + struct tintedglassobj* dstobj = (struct tintedglassobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->xludist, srcobj->xludist); + PD_CONV_VAL(dstobj->opadist, srcobj->opadist); + PD_CONV_VAL(dstobj->opacity, srcobj->opacity); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + PD_CONV_VAL(dstobj->unk64, srcobj->unk64); + + dst += sizeof(struct tintedglassobj); + break; + } + case OBJTYPE_LIFT: + { + struct n64_liftobj* srcobj = (struct n64_liftobj*)cmd; + struct liftobj* dstobj = (struct liftobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_ARRAY(dstobj->pads, srcobj->pads); + for (int k = 0; k < 4; k++) + PD_CONV_PTR(dstobj->doors[k], srcobj->ptr_doors[k]); + PD_CONV_VAL(dstobj->dist, srcobj->dist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->accel, srcobj->accel); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); + PD_CONV_VAL(dstobj->levelcur, srcobj->levelcur); + PD_CONV_VAL(dstobj->levelaim, srcobj->levelaim); + PD_CONV_VAL(dstobj->prevpos, srcobj->prevpos); + + dst += sizeof(struct liftobj); + break; + } + case OBJTYPE_CONDITIONALSCENERY: + { + struct n64_linksceneryobj* srcobj = (struct n64_linksceneryobj*)cmd; + struct linksceneryobj* dstobj = (struct linksceneryobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->trigger, srcobj->ptr_trigger); + PD_CONV_PTR(dstobj->unexp, srcobj->ptr_unexp); + PD_CONV_PTR(dstobj->exp, srcobj->ptr_exp); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct linksceneryobj); + break; + } + case OBJTYPE_BLOCKEDPATH: + { + struct n64_blockedpathobj* srcobj = (struct n64_blockedpathobj*)cmd; + struct blockedpathobj* dstobj = (struct blockedpathobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->blocker, srcobj->ptr_blocker); + PD_CONV_VAL(dstobj->waypoint1, srcobj->waypoint1); + PD_CONV_VAL(dstobj->waypoint2, srcobj->waypoint2); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct blockedpathobj); + break; + } + case OBJTYPE_HOVERBIKE: { + struct n64_hoverbikeobj* srcobj = (struct n64_hoverbikeobj*)cmd; + struct hoverbikeobj* dstobj = (struct hoverbikeobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->hov.type, srcobj->hov.type); + PD_CONV_VAL(dstobj->hov.flags, srcobj->hov.flags); + PD_CONV_VAL(dstobj->hov.bobycur, srcobj->hov.bobycur); + PD_CONV_VAL(dstobj->hov.bobytarget, srcobj->hov.bobytarget); + PD_CONV_VAL(dstobj->hov.bobyspeed, srcobj->hov.bobyspeed); + PD_CONV_VAL(dstobj->hov.yrot, srcobj->hov.yrot); + PD_CONV_VAL(dstobj->hov.bobpitchcur, srcobj->hov.bobpitchcur); + PD_CONV_VAL(dstobj->hov.bobpitchtarget, srcobj->hov.bobpitchtarget); + PD_CONV_VAL(dstobj->hov.bobpitchspeed, srcobj->hov.bobpitchspeed); + PD_CONV_VAL(dstobj->hov.bobrollcur, srcobj->hov.bobrollcur); + PD_CONV_VAL(dstobj->hov.bobrolltarget, srcobj->hov.bobrolltarget); + PD_CONV_VAL(dstobj->hov.bobrollspeed, srcobj->hov.bobrollspeed); + PD_CONV_VAL(dstobj->hov.groundpitch, srcobj->hov.groundpitch); + PD_CONV_VAL(dstobj->hov.y, srcobj->hov.y); + PD_CONV_VAL(dstobj->hov.ground, srcobj->hov.ground); + PD_CONV_VAL(dstobj->hov.prevframe60, srcobj->hov.prevframe60); + PD_CONV_VAL(dstobj->hov.prevgroundframe60, srcobj->hov.prevgroundframe60); + + PD_CONV_ARRAY(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->exreal, srcobj->exreal); + PD_CONV_VAL(dstobj->ezreal, srcobj->ezreal); + PD_CONV_VAL(dstobj->ezreal2, srcobj->ezreal2); + PD_CONV_VAL(dstobj->leanspeed, srcobj->leanspeed); + PD_CONV_VAL(dstobj->leandiff, srcobj->leandiff); + PD_CONV_VAL(dstobj->maxspeedtime240, srcobj->maxspeedtime240); + PD_CONV_ARRAY(dstobj->prevpos, srcobj->prevpos); + PD_CONV_ARRAY(dstobj->rels, srcobj->rels); + PD_CONV_ARRAY(dstobj->speedabs, srcobj->speedabs); + PD_CONV_ARRAY(dstobj->speedrel, srcobj->speedrel); + + dst += sizeof(struct hoverbikeobj); + break; + } + case OBJTYPE_HOVERPROP: + { + struct n64_hoverpropobj* srcobj = (struct n64_hoverpropobj*)cmd; + struct hoverpropobj* dstobj = (struct hoverpropobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->hov.type, srcobj->hov.type); + PD_CONV_VAL(dstobj->hov.flags, srcobj->hov.flags); + PD_CONV_VAL(dstobj->hov.bobycur, srcobj->hov.bobycur); + PD_CONV_VAL(dstobj->hov.bobytarget, srcobj->hov.bobytarget); + PD_CONV_VAL(dstobj->hov.bobyspeed, srcobj->hov.bobyspeed); + PD_CONV_VAL(dstobj->hov.yrot, srcobj->hov.yrot); + PD_CONV_VAL(dstobj->hov.bobpitchcur, srcobj->hov.bobpitchcur); + PD_CONV_VAL(dstobj->hov.bobpitchtarget, srcobj->hov.bobpitchtarget); + PD_CONV_VAL(dstobj->hov.bobpitchspeed, srcobj->hov.bobpitchspeed); + PD_CONV_VAL(dstobj->hov.bobrollcur, srcobj->hov.bobrollcur); + PD_CONV_VAL(dstobj->hov.bobrolltarget, srcobj->hov.bobrolltarget); + PD_CONV_VAL(dstobj->hov.bobrollspeed, srcobj->hov.bobrollspeed); + PD_CONV_VAL(dstobj->hov.groundpitch, srcobj->hov.groundpitch); + PD_CONV_VAL(dstobj->hov.y, srcobj->hov.y); + PD_CONV_VAL(dstobj->hov.ground, srcobj->hov.ground); + PD_CONV_VAL(dstobj->hov.prevframe60, srcobj->hov.prevframe60); + PD_CONV_VAL(dstobj->hov.prevgroundframe60, srcobj->hov.prevgroundframe60); + + dst += sizeof(struct hoverpropobj); + break; + } + case OBJTYPE_FAN: + { + struct n64_fanobj* srcobj = (struct n64_fanobj*)cmd; + struct fanobj* dstobj = (struct fanobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yrotprev, srcobj->yrotprev); + PD_CONV_VAL(dstobj->ymaxspeed, srcobj->ymaxspeed); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->yaccel, srcobj->yaccel); + PD_CONV_VAL(dstobj->on, srcobj->on); + + dst += sizeof(struct fanobj); + break; + } + case OBJTYPE_HOVERCAR: + { + struct n64_hovercarobj* srcobj = (struct n64_hovercarobj*)cmd; + struct hovercarobj* dstobj = (struct hovercarobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnyspeed60, srcobj->turnyspeed60); + PD_CONV_VAL(dstobj->turnxspeed60, srcobj->turnxspeed60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_VAL(dstobj->rotx, srcobj->rotx); + PD_CONV_VAL(dstobj->rotz, srcobj->rotz); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_VAL(dstobj->dead, srcobj->dead); + PD_CONV_VAL(dstobj->deadtimer60, srcobj->deadtimer60); + PD_CONV_VAL(dstobj->sparkstimer60, srcobj->sparkstimer60); + + dst += sizeof(struct hovercarobj); + break; + } + case OBJTYPE_PADEFFECT: + { + struct padeffectobj* srcobj = (struct padeffectobj*)cmd; + struct padeffectobj* dstobj = (struct padeffectobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->effect, srcobj->effect); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + + dst += sizeof(struct padeffectobj); + break; + } + case OBJTYPE_CHOPPER: + { + struct n64_chopperobj* srcobj = (struct n64_chopperobj*)cmd; + struct chopperobj* dstobj = (struct chopperobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnyspeed60, srcobj->turnyspeed60); + PD_CONV_VAL(dstobj->turnxspeed60, srcobj->turnxspeed60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_VAL(dstobj->rotx, srcobj->rotx); + PD_CONV_VAL(dstobj->rotz, srcobj->rotz); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + PD_CONV_VAL(dstobj->weaponsarmed, srcobj->weaponsarmed); + PD_CONV_VAL(dstobj->ontarget, srcobj->ontarget); + PD_CONV_VAL(dstobj->target, srcobj->target); + PD_CONV_VAL(dstobj->attackmode, srcobj->attackmode); + PD_CONV_VAL(dstobj->cw, srcobj->cw); + PD_CONV_VAL(dstobj->vx, srcobj->vx); + PD_CONV_VAL(dstobj->vy, srcobj->vy); + PD_CONV_VAL(dstobj->vz, srcobj->vz); + PD_CONV_VAL(dstobj->power, srcobj->power); + PD_CONV_VAL(dstobj->otx, srcobj->otx); + PD_CONV_VAL(dstobj->oty, srcobj->oty); + PD_CONV_VAL(dstobj->otz, srcobj->otz); + PD_CONV_VAL(dstobj->bob, srcobj->bob); + PD_CONV_VAL(dstobj->bobstrength, srcobj->bobstrength); + PD_CONV_VAL(dstobj->targetvisible, srcobj->targetvisible); + PD_CONV_VAL(dstobj->timer60, srcobj->timer60); + PD_CONV_VAL(dstobj->patroltimer60, srcobj->patroltimer60); + PD_CONV_VAL(dstobj->gunturnyspeed60, srcobj->gunturnyspeed60); + PD_CONV_VAL(dstobj->gunturnxspeed60, srcobj->gunturnxspeed60); + PD_CONV_VAL(dstobj->gunroty, srcobj->gunroty); + PD_CONV_VAL(dstobj->gunrotx, srcobj->gunrotx); + PD_CONV_VAL(dstobj->barrelrotspeed, srcobj->barrelrotspeed); + PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); + PD_CONV_PTR(dstobj->fireslotthing, srcobj->ptr_fireslotthing); + PD_CONV_VAL(dstobj->dead, srcobj->dead); + + dst += sizeof(struct chopperobj); + break; + } + case OBJTYPE_ESCASTEP: + { + struct n64_escalatorobj* srcobj = (struct n64_escalatorobj*)cmd; + struct escalatorobj* dstobj = (struct escalatorobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->frame, srcobj->frame); + PD_CONV_VAL(dstobj->prevpos, srcobj->prevpos); + + dst += sizeof(struct escalatorobj); + break; + } + } + + cmd = (struct n64_defaultobj*)((u32*)cmd + obj_size(cmd)); + type = cmd->type; + } + + *(u32*)(dst) = htobe32(OBJTYPE_END); + dst += sizeof(int); + + return (u32)(dst - start); +} + +static uintptr_t convert_intro(u8 *dst, u8 *src) +{ + u8* start = dst; + u8 cmd_size[] = { + 3, // INTROCMD_SPAWN + 4, // INTROCMD_WEAPON + 4, // INTROCMD_AMMO + 8, // INTROCMD_3 + 2, // INTROCMD_4 + 2, // INTROCMD_OUTFIT + 10, // INTROCMD_6 + 3, // INTROCMD_WATCHTIME + 2, // INTROCMD_CREDITOFFSET + 3, // INTROCMD_CASE + 3, // INTROCMD_CASERESPAWN + 2, // INTROCMD_HILL + 1, // INTROCMD_END + }; + + s32* dstintro = (s32*)dst; + s32* srcintro = (s32*)src; + + while (true) { + s32 cmd = dstintro[0] = srctodst32(srcintro[0]); + u8 size = cmd_size[*dstintro]; + for (int i = 1; i < size; i++) { + dstintro[i] = srctodst32(srcintro[i]); + } + + dstintro += size; + srcintro += size; + + if (cmd == INTROCMD_END) break; + } + + return (u32)((u8*)dstintro - start); +} + +static uintptr_t convert_paths(u8 *dst, u8 *src) +{ + u8* start = dst; + + struct n64_path* srcpath = (struct n64_path*)src; + struct path* dstpath = (struct path*)dst; + + while (true) { + PD_CONV_PTR(dstpath->pads, srcpath->ptr_pads); + PD_CONV_VAL(dstpath->id, srcpath->id); + PD_CONV_VAL(dstpath->flags, srcpath->flags); + PD_CONV_VAL(dstpath->len, srcpath->len); + + dstpath++; + + if (srcpath->ptr_pads == 0) break; + + srcpath ++; + } + + return (u32)((u8*)dstpath - start); +} + +static int convert_pads(struct path *dstpaths, u8 *dst, u8 *src, uintptr_t dstpos) +{ + uintptr_t start = dstpos; + s32* dstpads = (s32*)&dst[dstpos]; + s32 i = 0; + while (dstpaths->pads) { + s32 *pads = (s32*)&src[(uintptr_t)dstpaths->pads]; + dstpaths->pads = (s32*)dstpos; + + while (*pads) { + s32 p = srctoh32(*pads++); + *dstpads++ = p; + dstpos += sizeof(s32); + if (p == -1) break; + } + + dstpaths++; + } + + dstpaths->pads = 0; + return dstpos - start; +} + +static uintptr_t convert_ailists(u8* dst, u8* src) +{ + u8* start = dst; + + struct n64_ailist* srcailist = (struct n64_ailist*)src; + struct ailist* dstailist = (struct path*)dst; + + while (true) { + // at this point these fields are already converted, so we just assign + dstailist->list = srcailist->ptr_list; + dstailist->id = srcailist->id; + + dstailist++; + + if (srcailist->ptr_list == 0) break; + + srcailist++; + } + + return (u32)((u8*)dstailist - start); +} + +static int convert_lists(uintptr_t ofs_ailists, u8 *dst, u8 *src, uintptr_t dstpos) +{ + struct n64_ailist* ailists = (struct n64_ailist*)&src[ofs_ailists]; + + // count the lists and pre-convert the fields + int nlists = 0; + for (struct n64_ailist* tmp = ailists; tmp->ptr_list; tmp++, nlists++) { + tmp->ptr_list = srctodst32(tmp->ptr_list); + tmp->id = srctodst32(tmp->id); + } + + // sort ailists by the list addr + for (int i = 0; i < nlists; i++) { + uintptr_t minidx = i; + + for (int j = i + 1; j < nlists; j++) + if (ailists[j].ptr_list < ailists[minidx].ptr_list) minidx = j; + + struct n64_ailist tmp = ailists[i]; + ailists[i] = ailists[minidx]; + ailists[minidx] = tmp; + } + + for (int i = 0; i < nlists; i++) { + u8* start = (u8*)&src[(uintptr_t)ailists[i].ptr_list]; + u8* end = (i == nlists - 1) ? &src[ofs_ailists] : &src[(uintptr_t)ailists[i + 1].ptr_list]; + + size_t size = end - start; + + // update the src list pointers as we go + ailists[i].ptr_list = (u8*)dstpos; + + if (size > 0) + memcpy(dst + dstpos, start, size); + + dstpos += size; + + } + return dstpos; +} + +static int convert_setup(u8 *dst, u8 *src, u32 srclen) +{ + struct n64_stagesetup *src_header = (struct n64_stagesetup*)src; + struct stagesetup *dst_header = (struct stagesetup*)dst; + + src_header->ptr_props = srctodst32(src_header->ptr_props); + src_header->ptr_intro = srctodst32(src_header->ptr_intro); + src_header->ptr_ailists = srctodst32(src_header->ptr_ailists); + src_header->ptr_paths = srctodst32(src_header->ptr_paths); + + u32 srcpos = sizeof(*src_header); + u32 dstpos = sizeof(*dst_header); + + srcpos = src_header->ptr_props; + dst_header->props = (u32*) dstpos; + dstpos += convert_props(&dst[dstpos], &src[srcpos]); + + srcpos = src_header->ptr_intro; + dst_header->intro = (u32*) dstpos; + dstpos += convert_intro(&dst[dstpos], &src[srcpos]); + + srcpos = src_header->ptr_paths; + dst_header->paths = (struct path*) dstpos; + dstpos += convert_paths(&dst[dstpos], &src[srcpos]); + + // write the lists bytecodes before the ailists entries + dstpos += convert_lists(src_header->ptr_ailists, dst, src, dstpos); + + srcpos = src_header->ptr_ailists; + dst_header->ailists = (struct ailist*) dstpos; + dstpos += convert_ailists(&dst[dstpos], &src[srcpos]); + + dstpos += convert_pads(&dst[(uintptr_t)dst_header->paths], dst, src, dstpos); + + return dstpos; +} + + +void test_conv_functions() +{ + f32 dst0; + f32 src0 = 3.141592; + PD_CONV_VAL(dst0, src0); + + u32 dst1; + u32 src1 = 0xaabbccdd; + PD_CONV_VAL(dst1, src1); + + s32 dst2; + s32 src2 = 0xaabbccdd; + PD_CONV_VAL(dst2, src2); + + u16 dst3; + u16 src3 = 0xaabb; + PD_CONV_VAL(dst3, src3); + + s16 dst4; + s16 src4 = 0xaabb; + PD_CONV_VAL(dst4, src4); + + struct coord dst5; + struct n64_coord src5 = { 1.0f, 2.0f, 3.0f }; + PD_CONV_VAL(dst5, src5); + + s32* dst6; + s32* src6 = (s32*)0xcafebaca; + PD_CONV_PTR(dst6, src6); + + s32 dst7[3]; + s32 src7[3] = { 0xaabbccdd, 0x11223344, 0xddbbccaa }; + PD_CONV_ARRAY(dst7, src7); + + s32 dst8[2][2]; + s32 src8[2][2] = { + { 0xaabbccdd, 0x11223344 }, + { 0xffeeddcc, 0x55667788 } + }; + PD_CONV_ARRAY2D(dst8, src8); +} + +void extract_file_setups(char* filename, u32 romoffset, size_t len) +{ + // Unzip it + size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); + u8* src = malloc(infsize); + + int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); + + if (ret < 0) { + sysLogPrintf(LOG_ERROR, "%s: Unable to inflate file: %d", filename, ret); + exit(EXIT_FAILURE); + } + + // Convert it + u8* dst = calloc(1, infsize * 4); + + int* mark = strstr(filename, "mp_setupdam"); + u32 dstpos = convert_setup(dst, src, infsize); + + if (dstpos > infsize * 4) { + sysLogPrintf(LOG_ERROR, "%s: overflow", filename); + exit(EXIT_FAILURE); + } + + sysLogPrintf(LOG_NOTE, "%s %d %d %.3f", filename, infsize, dstpos, (f32)dstpos / infsize); + + // Zip it + u8* zipped = calloc(1, dstpos); + size_t ziplen = dstpos; + + ret = rzip_deflate(zipped, &ziplen, dst, dstpos); + + if (ret < 0) { + sysLogPrintf(LOG_ERROR, "%s: Unable to compress file: %d", filename, ret); + exit(EXIT_FAILURE); + } + + ziplen = ALIGN16(ziplen); + + // Write it + char outfilename[1024]; + sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + + FILE* fp = openfile(outfilename); + fwrite(zipped, ziplen, 1, fp); + fclose(fp); + + free(zipped); + free(dst); + free(src); +} \ No newline at end of file diff --git a/port/pdextract/setups_decl.h b/port/pdextract/setups_decl.h new file mode 100644 index 000000000..ab650168b --- /dev/null +++ b/port/pdextract/setups_decl.h @@ -0,0 +1,644 @@ +#ifndef _IN_SETUP_DECL +#define _IN_SETUP_DECL + + +#include +#include "common.h" + + +struct n64_stagesetup { + u32 ptr_waypoints; + u32 ptr_waygroups; + u32 ptr_cover; + u32 ptr_intro; + u32 ptr_props; + u32 ptr_paths; + u32 ptr_ailists; + u32 ptr_padfiledata; +}; + + +struct n64_coord { + f32 x; + f32 y; + f32 z; +}; + +struct n64_defaultobj { + u16 extrascale; + u8 hidden2; + u8 type; + s16 modelnum; + s16 pad; + u32 flags; + u32 flags2; + u32 flags3; + u32 ptr_prop; + u32 ptr_model; + f32 realrot[3][3]; + u32 hidden; + union { + u32 ptr_geotilef; + u32 ptr_geoblock; + u32 ptr_geocyl; + u32 ptr_unkgeo; + }; + union { + u32 ptr_projectile; + u32 ptr_embedment; + }; + s16 damage; + s16 maxdamage; + u8 shadecol[4]; + u8 nextcol[4]; + u16 floorcol; + s8 geocount; + s8 _pad_; +}; + +struct n64_doorobj { + struct n64_defaultobj base; + f32 maxfrac; + f32 perimfrac; + f32 accel; + f32 decel; + f32 maxspeed; + u16 doorflags; + u16 doortype; + u32 keyflags; + s32 autoclosetime; + f32 frac; + f32 fracspeed; + s8 mode; + s8 glasshits; + s16 fadealpha; + s16 xludist; + s16 opadist; + struct n64_coord startpos; + f32 mtx98[3][3]; + u32 ptr_sibling; + s32 lastopen60; + s16 portalnum; + s8 soundtype; + s8 fadetime60; + s32 lastcalc60; + u8 laserfade; + u8 unusedmaybe[3]; + u8 shadeinfo1[4]; + u8 shadeinfo2[4]; + u8 actual1; + u8 actual2; + u8 extra1; + u8 extra2; +}; + +struct n64_doorscaleobj { + u32 unk00; + s32 scale; +}; + +struct n64_keyobj { + struct n64_defaultobj base; + u32 keyflags; +}; + +struct n64_alarmobj { + struct n64_defaultobj base; +}; + +struct n64_cctvobj { + struct n64_defaultobj base; + + s16 lookatpadnum; + s16 toleft; + //Mtxf camrotm; + f32 m[4][4]; + f32 yzero; + f32 yrot; + f32 yleft; + f32 yright; + f32 yspeed; + f32 ymaxspeed; + s32 seebondtime60; + f32 maxdist; + f32 xzero; +}; + +struct n64_ammocrateobj { + struct n64_defaultobj base; + s32 ammotype; +}; + +struct n64_gset { + u8 weaponnum; + u8 unk0639; + u8 unk063a; + u8 weaponfunc; +}; + +struct n64_weaponobj { + struct n64_defaultobj base; + + union { + struct n64_gset gset; + struct { + u8 weaponnum; + s8 unk5d; + s8 unk5e; + u8 gunfunc; + }; + }; + + s8 fadeouttimer60; + s8 dualweaponnum; + + union { + s16 timer240; + s16 team; + }; + + u32 ptr_dualweapon; +}; + +struct n64_packedchr { + s16 chrindex; + s8 unk02; + s8 typenum; + u32 spawnflags; + s16 chrnum; + u16 padnum; + u8 bodynum; + s8 headnum; + u16 ailistnum; + u16 padpreset; + u16 chrpreset; + u16 hearscale; + u16 viewdist; + u32 flags; + u32 flags2; + u8 team; + u8 squadron; + s16 chair; + u32 convtalk; + u8 tude; + u8 naturalanim; + u8 yvisang; + u8 teamscandist; +}; + +struct n64_tvscreen { + u32 ptr_cmdlist; + u16 offset; + s16 pause60; + u32 ptr_tconfig; + f32 rot; + f32 xscale; + f32 xscalefrac; + f32 xscaleinc; + f32 xscaleold; + f32 xscalenew; + f32 yscale; + f32 yscalefrac; + f32 yscaleinc; + f32 yscaleold; + f32 yscalenew; + f32 xmid; + f32 xmidfrac; + f32 xmidinc; + f32 xmidold; + f32 xmidnew; + f32 ymid; + f32 ymidfrac; + f32 ymidinc; + f32 ymidold; + f32 ymidnew; + u8 red; + u8 redold; + u8 rednew; + u8 green; + u8 greenold; + u8 greennew; + u8 blue; + u8 blueold; + u8 bluenew; + u8 alpha; + u8 alphaold; + u8 alphanew; + f32 colfrac; + f32 colinc; +}; + +struct n64_singlemonitorobj { + struct n64_defaultobj base; + struct n64_tvscreen screen; + s16 owneroffset; + s8 ownerpart; + u8 imagenum; +}; + +struct n64_multimonitorobj { + struct n64_defaultobj base; + struct n64_tvscreen screens[4]; + u8 imagenums[4]; +}; + +struct n64_hangingmonitorsobj { + struct n64_defaultobj base; +}; + +struct n64_autogunobj { + struct n64_defaultobj base; + s16 targetpad; + s8 firing; + u8 firecount; + f32 yzero; + f32 ymaxleft; + f32 ymaxright; + f32 yrot; + f32 yspeed; + f32 xzero; + f32 xrot; + f32 xspeed; + f32 maxspeed; + f32 aimdist; + f32 barrelspeed; + f32 barrelrot; + s32 lastseebond60; + s32 lastaimbond60; + s32 allowsoundframe; + u32 ptr_beam; + f32 shotbondsum; + u32 ptr_target; + u8 targetteam; + u8 ammoquantity; + s16 nextchrtest; +}; + +struct n64_linkgunsobj { + u32 unk00; + s16 offset1; + s16 offset2; +}; + +struct n64_debrisobj { + struct n64_defaultobj base; +}; + +struct n64_hatobj { + struct n64_defaultobj base; +}; + +struct n64_grenadeprobobj { // objtype 0x12 + u32 unk00; + s16 chrnum; + u16 probability; +}; + +struct n64_linkliftdoorobj { + u32 unk00; + u32 ptr_door; + u32 ptr_lift; + u32 ptr_next; + s32 stopnum; +}; + +struct n64_multiammocrateslot { + u16 modelnum; + u16 quantity; +}; + +struct n64_multiammocrateobj { + struct n64_defaultobj base; + struct n64_multiammocrateslot slots[19]; +}; + +struct n64_shieldobj { + struct n64_defaultobj base; + f32 initialamount; + f32 amount; + u32 unk64; +}; + +struct n64_tag { + u32 identifier; + u16 tagnum; + s16 cmdoffset; + u32 ptr_next; + u32 ptr_obj; +}; + +struct n64_objective { + u32 unk00; + s32 index; + u32 text; + u16 unk0c; + u8 flags; + s8 difficulties; +}; + +struct n64_stdobjective { + u32 cmd; +}; + +struct n64_objectivecmd { + u8 cmd0[4]; + u32 cmd1; +}; + +struct n64_briefingobj { + u32 unk00; + u32 type; + u32 text; + u32 ptr_next; +}; + +struct n64_padlockeddoorobj { + u32 unk00; + u32 ptr_door; + u32 ptr_lock; + u32 ptr_next; +}; + +struct n64_truckobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 speed; + f32 wheelxrot; + f32 wheelyrot; + f32 speedaim; + f32 speedtime60; + f32 turnrot60; + f32 roty; + u32 ptr_path; + s32 nextstep; +}; + +struct n64_tankobj { + u8 _pad_[128]; +}; + +struct n64_heliobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 rotoryrot; + f32 rotoryspeed; + f32 rotoryspeedaim; + f32 rotoryspeedtime; + f32 speed; + f32 speedaim; + f32 speedtime60; + f32 yrot; + u32 ptr_path; + s32 nextstep; +}; + +struct n64_glassobj { + struct n64_defaultobj base; + s16 portalnum; + s16 _pad_; +}; + +struct n64_safeobj { + struct n64_defaultobj base; +}; + +struct n64_safeitemobj { + u32 unk00; + u32 ptr_item; + u32 ptr_safe; + u32 ptr_door; + u32 ptr_next; +}; + +struct n64_cameraposobj { + s32 type; + f32 x; + f32 y; + f32 z; + f32 theta; + f32 verta; + s32 pad; +}; + +struct n64_tintedglassobj { + struct n64_defaultobj base; + s16 xludist; + s16 opadist; + s16 opacity; + s16 portalnum; + f32 unk64; +}; + +struct n64_liftobj { + struct n64_defaultobj base; + s16 pads[4]; + u32 ptr_doors[4]; + f32 dist; + f32 speed; + f32 accel; + f32 maxspeed; + s8 soundtype; + s8 levelcur; + s8 levelaim; + s8 _pad_; + struct n64_coord prevpos; +}; + +struct n64_linksceneryobj { + u32 unk00; + u32 ptr_trigger; + u32 ptr_unexp; + u32 ptr_exp; + u32 ptr_next; +}; + +struct n64_blockedpathobj { + u32 unk00; + u32 ptr_blocker; + s16 waypoint1; + s16 waypoint2; + u32 ptr_next; +}; + +struct n64_hov { + u8 type; + u8 flags; + s16 _pad_; + f32 bobycur; + f32 bobytarget; + f32 bobyspeed; + f32 yrot; + f32 bobpitchcur; + f32 bobpitchtarget; + f32 bobpitchspeed; + f32 bobrollcur; + f32 bobrolltarget; + f32 bobrollspeed; + f32 groundpitch; + f32 y; + f32 ground; + s32 prevframe60; + s32 prevgroundframe60; +}; + +struct n64_hoverbikeobj { + struct n64_defaultobj base; + struct n64_hov hov; + f32 speed[2]; + f32 prevpos[2]; + f32 w; + f32 rels[2]; + f32 exreal; + f32 ezreal; + f32 ezreal2; + f32 leanspeed; + f32 leandiff; + s32 maxspeedtime240; + f32 speedabs[2]; + f32 speedrel[2]; +}; + +struct n64_hoverpropobj { + struct n64_defaultobj base; + struct n64_hov hov; +}; + +struct n64_fanobj { + struct n64_defaultobj base; + f32 yrot; + f32 yrotprev; + f32 ymaxspeed; + f32 yspeed; + f32 yaccel; + s8 on; + u8 _pad_[3]; +}; + +struct n64_hovercarobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 speed; + f32 speedaim; + f32 speedtime60; + f32 turnyspeed60; + f32 turnxspeed60; + f32 turnrot60; + f32 roty; + f32 rotx; + f32 rotz; + u32 ptr_path; + s32 nextstep; + s16 status; + s16 dead; + s16 deadtimer60; + s16 sparkstimer60; +}; + +struct n64_chopperobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + union { + struct { + f32 speed; + f32 speedaim; + f32 speedtime60; + }; + struct n64_coord fall; + }; + f32 turnyspeed60; + f32 turnxspeed60; + f32 turnrot60; + f32 roty; + f32 rotx; + f32 rotz; + u32 ptr_path; + s32 nextstep;// + s16 weaponsarmed; + s16 ontarget; + s16 target; + u8 attackmode; + u8 cw; + f32 vx; + f32 vy; + f32 vz; + f32 power; + f32 otx; + f32 oty; + f32 otz; + f32 bob; + f32 bobstrength; + s32 targetvisible; + s32 timer60; + s32 patroltimer60; + f32 gunturnyspeed60; + f32 gunturnxspeed60; + f32 gunroty; + f32 gunrotx; + f32 barrelrotspeed; + f32 barrelrot; + u32 ptr_fireslotthing; + s32 dead; +}; + +struct n64_escalatorobj { + struct n64_defaultobj base; + s32 frame; + struct n64_coord prevpos; +}; + +struct n64_textoverride { + u32 unk00; + s32 objoffset; + s32 weapon; + u32 obtaintext; + u32 ownertext; + u32 inventorytext; + u32 inventory2text; + u32 pickuptext; + u32 ptr_next; + u32 ptr_obj; +}; + +struct n64_criteria_roomentered { + u32 unk00; + u32 pad; + u32 status; + u32 ptr_next; +}; + +struct n64_criteria_throwinroom { + u32 unk00; + u32 unk04; + u32 pad; + u32 status; + u32 ptr_next; +}; + +struct n64_criteria_holograph { + u32 unk00; + u32 obj; + u32 status; + u32 ptr_next; +}; + +struct n64_ailist { + u32 ptr_list; + s32 id; +}; + +struct n64_path { + u32 ptr_pads; + u8 id; + u8 flags; + u16 len; +}; + +#endif \ No newline at end of file From 86649345cd15a722fdfee1eb06a648e72c1dbe48 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Tue, 30 Jul 2024 17:56:40 +0800 Subject: [PATCH 12/81] portx64: undo this nonsense --- src/game/playerreset.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/game/playerreset.c b/src/game/playerreset.c index 346dedc97..67363dec7 100644 --- a/src/game/playerreset.c +++ b/src/game/playerreset.c @@ -431,10 +431,6 @@ void playerReset(void) g_Vars.currentplayer->bond2.unk00.y = 0; g_Vars.currentplayer->bond2.unk00.z = cosf(turnanglerad); - // #TEMP - g_Vars.currentplayer->prop->pos.f[0] = -1101.97473; - g_Vars.currentplayer->prop->pos.f[1] = 481.576385; - g_Vars.currentplayer->prop->pos.f[2] = 283.67334; g_Vars.currentplayer->prop->pos.f[0] = g_Vars.currentplayer->bondprevpos.f[0] = pos.f[0]; g_Vars.currentplayer->prop->pos.f[1] = g_Vars.currentplayer->bondprevpos.f[1] = pos.f[1]; From 06c01208d32f86c3ce75d02461e3bd31e3f22a21 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 16:43:21 +0800 Subject: [PATCH 13/81] portx64: integrate pd-extract functions with romdata --- port/pdextract/common.h | 40 +--- port/pdextract/ext_anims.c | 78 ------- port/pdextract/ext_audio.c | 83 +------- port/pdextract/ext_banners.c | 39 ---- port/pdextract/ext_file_audio.c | 14 -- port/pdextract/ext_file_bg.c | 295 +++++++-------------------- port/pdextract/ext_file_lang.c | 49 ++--- port/pdextract/ext_file_model.c | 72 +------ port/pdextract/ext_file_pads.c | 47 ++--- port/pdextract/ext_file_tiles.c | 52 ++--- port/pdextract/ext_files.c | 100 --------- port/pdextract/ext_fonts.c | 95 +++------ port/pdextract/ext_jpnfonts.c | 32 --- port/pdextract/ext_setups.c | 73 ++----- port/pdextract/ext_textures.c | 76 ------- port/pdextract/main.c | 173 ---------------- port/pdextract/setups_decl.h | 2 - port/pdextract/{gbi.c => util_gbi.c} | 0 port/src/preprocess.c | 48 +++-- port/src/romdata.c | 73 ++++--- src/game/file.c | 2 +- src/include/constants.h | 2 + 22 files changed, 278 insertions(+), 1167 deletions(-) delete mode 100644 port/pdextract/ext_anims.c delete mode 100644 port/pdextract/ext_banners.c delete mode 100644 port/pdextract/ext_file_audio.c delete mode 100644 port/pdextract/ext_files.c delete mode 100644 port/pdextract/ext_jpnfonts.c delete mode 100644 port/pdextract/ext_textures.c delete mode 100644 port/pdextract/main.c rename port/pdextract/{gbi.c => util_gbi.c} (100%) diff --git a/port/pdextract/common.h b/port/pdextract/common.h index f6f1387b6..665bd6d48 100644 --- a/port/pdextract/common.h +++ b/port/pdextract/common.h @@ -6,8 +6,17 @@ #include #include +// this BS comes from windows.h +#undef near +#undef far + #include +#include + +#include "constants.h" + + #if __BIG_ENDIAN__ #define htonll(x) (x) #define ntohll(x) (x) @@ -60,37 +69,6 @@ #define uintptr_t uint32_t #endif -enum romversion { - ROMVERSION_NTSC10, - ROMVERSION_NTSCFINAL, - ROMVERSION_PALFINAL, - ROMVERSION_JPNFINAL, - ROMVERSION_NTSCBETA, - ROMVERSION_PALBETA, - ROMVERSION_UNKNOWN, -}; - -extern uint8_t *g_Rom; -extern enum romversion g_RomVersion; -extern char g_OutPath[1024]; - -typedef uint32_t n64ptr_t; - -#define ALIGN(val, size) ((val + (size - 1)) & ~(size - 1)) -#define ALIGN16(val) ((val + 0xf) & ~0xf) -#define ALIGN8(val) ((val + 0x7) & ~0x7) -#define ALIGN4(val) ((val + 0x3) & ~0x3) - -#define ARRAYCOUNT(arr) (int) (sizeof(arr) / sizeof(arr[0])) - -#define MIN(a, b) ((a) < (b) ? (a) : (b)) -#define MAX(a, b) ((a) > (b) ? (a) : (b)) - -FILE *openfile(char *filename); -size_t rzip_get_infsize(uint8_t *src); -int rzip_inflate(uint8_t *dst, size_t dstlen, uint8_t *src, size_t srclen); -int rzip_deflate(uint8_t *dst, size_t *dstlen, uint8_t *src, size_t srclen); - void gbi_reset(void); void gbi_set_segment(int segment, uint32_t offset); void gbi_set_vtx(uint32_t src_offset, uint32_t dst_offset); diff --git a/port/pdextract/ext_anims.c b/port/pdextract/ext_anims.c deleted file mode 100644 index e833d472d..000000000 --- a/port/pdextract/ext_anims.c +++ /dev/null @@ -1,78 +0,0 @@ -#include -#include -#include -#include "common.h" - -struct animtableentry { - uint16_t numframes; - uint16_t bytesperframe; - uint32_t data; - uint16_t headerlen; - uint8_t framelen; - uint8_t flags; -}; - -static void extract_anims_data(uint32_t romoffset, size_t len) -{ - char outfilename[1024]; - sprintf(outfilename, "%s/anims_data.bin", g_OutPath); - - FILE *fp = openfile(outfilename); - fwrite(&g_Rom[romoffset], len, 1, fp); - fclose(fp); -} - -static void extract_anims_table(uint32_t data_offset, uint32_t table_offset) -{ - int num_anims = srctoh32(*(uint32_t *) &g_Rom[table_offset]); - struct animtableentry *srcanims = (struct animtableentry *) &g_Rom[table_offset + 4]; - - size_t dstlen = ALIGN16(4 + num_anims * sizeof(struct animtableentry)); - uint8_t *dst = calloc(1, dstlen); - *(uint32_t *) dst = htodst32(num_anims); - struct animtableentry *dstanims = (struct animtableentry *) (dst + 4); - - for (int i = 0; i < num_anims; i++) { - dstanims[i].numframes = srctodst16(srcanims[i].numframes); - dstanims[i].bytesperframe = srctodst16(srcanims[i].bytesperframe); - dstanims[i].data = srctodst32(srcanims[i].data); - dstanims[i].headerlen = srctodst16(srcanims[i].headerlen); - dstanims[i].framelen = srcanims[i].framelen; - dstanims[i].flags = srcanims[i].flags; - } - - char outfilename[1024]; - sprintf(outfilename, "%s/segs/animations", g_OutPath); - - FILE *fp = openfile(outfilename); - size_t datalen = table_offset - data_offset; - fwrite(&g_Rom[data_offset], datalen, 1, fp); - fwrite(dst, dstlen, 1, fp); - fclose(fp); - - free(dst); -} - -void extract_anims(void) -{ - uint32_t table_offset = 0; - uint32_t data_offset = 0; - - switch (g_RomVersion) { - case ROMVERSION_NTSC10: - case ROMVERSION_NTSCFINAL: - data_offset = 0x1a15c0; - table_offset = 0x7cd1a0; - break; - case ROMVERSION_PALFINAL: - data_offset = 0x18cdc0; - table_offset = 0x7b89a0; - break; - case ROMVERSION_JPNFINAL: - data_offset = 0x190c50; - table_offset = 0x7bc830; - break; - } - - extract_anims_table(data_offset, table_offset); -} diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c index 15ffd43d4..dbf8e27c5 100644 --- a/port/pdextract/ext_audio.c +++ b/port/pdextract/ext_audio.c @@ -391,95 +391,34 @@ static int convert_audio_bank(uint8_t *dst, int dstpos, uint8_t *src, int srcpos return dstpos; } -static int convert_audio_bankfile(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_bankfile(uint8_t *dst, uint8_t *src) { - struct n64_bankfile *n64_bankfile = (struct n64_bankfile *) &src[srcpos]; - struct host_bankfile *host_bankfile = (struct host_bankfile *) &dst[dstpos]; + struct n64_bankfile *n64_bankfile = (struct n64_bankfile *)src; + struct host_bankfile *host_bankfile = (struct host_bankfile *)dst; int bankCount = srctoh16(n64_bankfile->bankCount); host_bankfile->revision = srctodst16(n64_bankfile->revision); host_bankfile->bankCount = htodst16(bankCount); - dstpos = dstpos + sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); + + uint32_t dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); for (int i = 0; i < bankCount; i++) { host_bankfile->bankArray[i] = htodst32(dstpos); - srcpos = srctoh32(n64_bankfile->bankArray[i]); + uint32_t srcpos = srctoh32(n64_bankfile->bankArray[i]); dstpos = convert_audio_bank(dst, dstpos, src, srcpos); } return dstpos; } -static void extract_audio_ctl(const char *filename, uint32_t romoffset, size_t srclen) +uint8_t *preprocessALBankFile_x64(uint8_t *src, uint32_t size, uint32_t *outSize) { - size_t dstlen = srclen * 4; - uint8_t *src = &g_Rom[romoffset]; + size_t dstlen = size * 4; uint8_t *dst = calloc(1, dstlen); - int dstpos = 0; - dstpos = convert_audio_bankfile(dst, dstpos, src, 0); + *outSize = convert_audio_bankfile(dst, src); + *outSize = ALIGN16(*outSize); - char outfilename[1024]; - sprintf(outfilename, "%s/segs/%sctl", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(dst, ALIGN16(dstpos), 1, fp); - fclose(fp); - - free(dst); -} - -static void extract_audio_tbl(const char *filename, uint32_t romoffset, size_t len) -{ - char outfilename[1024]; - sprintf(outfilename, "%s/segs/%stbl", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(&g_Rom[romoffset], len, 1, fp); - fclose(fp); -} - -void extract_audio(void) -{ - uint32_t sfx_ctl = 0; - uint32_t sfx_tbl = 0; - uint32_t sfx_end = 0; - - uint32_t seq_ctl = 0; - uint32_t seq_tbl = 0; - uint32_t seq_end = 0; - - switch (g_RomVersion) { - case ROMVERSION_NTSC10: - case ROMVERSION_NTSCFINAL: - sfx_ctl = 0x80a250; - sfx_tbl = 0x839dd0; - sfx_end = 0xcfbf30; - seq_ctl = 0xcfbf30; - seq_tbl = 0xd05f90; - seq_end = 0xe82000; - break; - case ROMVERSION_PALFINAL: - sfx_ctl = 0x7f87e0; - sfx_tbl = 0x828360; - sfx_end = 0xcea4c0; - seq_ctl = 0xcea4c0; - seq_tbl = 0xcf4520; - seq_end = 0xe70590; - break; - case ROMVERSION_JPNFINAL: - sfx_ctl = 0x7fc670; - sfx_tbl = 0x82c1f0; - sfx_end = 0xcee350; - seq_ctl = 0xcee350; - seq_tbl = 0xcf83b0; - seq_end = 0xe74420; - break; - } - - extract_audio_ctl("sfx", sfx_ctl, sfx_tbl - sfx_ctl); - extract_audio_tbl("sfx", sfx_tbl, sfx_end - sfx_tbl); - extract_audio_ctl("seq", seq_ctl, seq_tbl - seq_ctl); - extract_audio_tbl("seq", seq_tbl, seq_end - seq_tbl); + return dst; } diff --git a/port/pdextract/ext_banners.c b/port/pdextract/ext_banners.c deleted file mode 100644 index dd9b3370e..000000000 --- a/port/pdextract/ext_banners.c +++ /dev/null @@ -1,39 +0,0 @@ -#include -#include -#include -#include "common.h" - -void extract_banner(const char *filename, uint32_t romoffset, size_t len) -{ - char outfilename[1024]; - sprintf(outfilename, "%s/%s.bin", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(&g_Rom[romoffset], len, 1, fp); - fclose(fp); -} - -void extract_banners(void) -{ - uint32_t accessingpak = 0; - uint32_t copyright = 0; - - switch (g_RomVersion) { - case ROMVERSION_NTSC10: - case ROMVERSION_NTSCFINAL: - copyright = 0x1ffea20; - accessingpak = 0x1fff550; - break; - case ROMVERSION_PALFINAL: - copyright = 0x1ff5500; - accessingpak = 0x1ff6030; - break; - case ROMVERSION_JPNFINAL: - copyright = 0x1ffd6b0; - accessingpak = 0x1ffe1e0; - break; - } - - extract_banner("copyright", copyright, 0xb30); - extract_banner("accessingpak", accessingpak, 0x8b0); -} diff --git a/port/pdextract/ext_file_audio.c b/port/pdextract/ext_file_audio.c deleted file mode 100644 index 3411034fa..000000000 --- a/port/pdextract/ext_file_audio.c +++ /dev/null @@ -1,14 +0,0 @@ -#include -#include -#include -#include "common.h" - -void extract_file_audio(char *filename, uint32_t romoffset, size_t len) -{ - char outfilename[1024]; - sprintf(outfilename, "%s/files/%s", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(&g_Rom[romoffset], len, 1, fp); - fclose(fp); -} diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c index 1c2921ffe..d756678d0 100644 --- a/port/pdextract/ext_file_bg.c +++ b/port/pdextract/ext_file_bg.c @@ -4,6 +4,7 @@ #include #include "common.h" #include "system.h" +#include "platform.h" struct ptrmarker { uint32_t ptr_src; @@ -18,7 +19,7 @@ int m_SizeGDLs; static void add_marker(uint32_t ptr_src, uintptr_t ptr_host) { if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { - fprintf(stderr, "[BG] Marker limit exceeded\n"); + sysLogPrintf(LOG_ERROR, "[BG] Marker limit exceeded"); exit(EXIT_FAILURE); } @@ -216,7 +217,7 @@ static void convert_primary_rooms(uint8_t *dst, uint32_t *dstpos, uint8_t *src, } for (int i = 0; i < m_NumRooms + 1; i++) { - host_rooms[i].ptr_gfxdata = 0; // Not known at this point + host_rooms[i].ptr_gfxdata = srctodst32(n64_rooms[i].ptr_gfxdata); host_rooms[i].pos[0] = srctodst32(n64_rooms[i].pos[0]); host_rooms[i].pos[1] = srctodst32(n64_rooms[i].pos[1]); host_rooms[i].pos[2] = srctodst32(n64_rooms[i].pos[2]); @@ -273,9 +274,9 @@ static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src } } -static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t dst_portalvtxs, uint32_t src_portalvtxs) +static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t dst_portalvtxs, uint32_t src_portalvtxs) { - struct bgcmd *n64_cmds = (struct bgcmd *) &src[*srcpos]; + struct bgcmd *n64_cmds = (struct bgcmd *) src; struct bgcmd *host_cmds = (struct bgcmd *) &dst[*dstpos]; int num_cmds = 0; @@ -296,7 +297,6 @@ static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, } } - *srcpos += sizeof(*n64_cmds) * num_cmds; *dstpos += sizeof(*host_cmds) * num_cmds; } @@ -347,25 +347,17 @@ void relink_ptr(uintptr_t** ptr) *ptr = marker->ptr_host; } -static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t compsize, uint32_t src_roomoffset, uint32_t dst_roomoffset) +static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_t infsize, uint32_t src_ofs) { reset_markers(); - dst_roomoffset += 0x0f000000; - size_t infsize = rzip_get_infsize(src); - uint8_t* src_roomgfxdata = calloc(1, infsize); - int ret = rzip_inflate(src_roomgfxdata, infsize, src, compsize); - - if (ret < 0) { - fprintf(stderr, "Unable to inflate roomgfxdata %d\n", ret); - exit(EXIT_FAILURE); - } + uint32_t dst_roomoffset = src_ofs; uintptr_t gdls_addr[64]; int numgdls = 0; - struct n64_roomgfxdata *src_header = (struct n64_roomgfxdata*)src_roomgfxdata; - struct host_roomgfxdata *dst_header = (struct host_roomgfxdata*)&dst[dstpos]; + struct n64_roomgfxdata *src_header = (struct n64_roomgfxdata*)src; + struct host_roomgfxdata *dst_header = (struct host_roomgfxdata*)dst; dst_header->ptr_vertices = srctoh32(src_header->ptr_vertices); dst_header->ptr_colours = srctoh32(src_header->ptr_colours); @@ -376,7 +368,7 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint dst_header->numvertices = srctoh16(src_header->numvertices); dst_header->numcolours = srctoh16(src_header->numcolours); - intptr_t endpos = dst_header->ptr_vertices - src_roomoffset; + intptr_t endpos = dst_header->ptr_vertices - src_ofs; uintptr_t curpos_src = sizeof(struct n64_roomgfxdata); uintptr_t curpos_dst = sizeof(struct host_roomgfxdata); @@ -388,7 +380,7 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint int numblocks = 0; while ((intptr_t)(curpos_src + sizeof(struct n64_roomblock)) <= endpos) { - struct n64_roomblock *src_roomblock = (struct n64_roomblock*)&src_roomgfxdata[curpos_src]; + struct n64_roomblock *src_roomblock = (struct n64_roomblock*)&src[curpos_src]; struct host_roomblock *dest_roomblock = (struct host_roomblock*)&dst[curpos_dst]; dest_roomblock->type = src_roomblock->type; @@ -397,15 +389,15 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint dest_roomblock->ptr_vertices = srctoh32(src_roomblock->ptr_vertices); dest_roomblock->ptr_colours = srctoh32(src_roomblock->ptr_colours); - add_marker(curpos_src + src_roomoffset, curpos_dst + dst_roomoffset); + add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); if (src_roomblock->type == BLOCK_PARENT) { ncoords++; - uintptr_t vtx_ptr = dest_roomblock->ptr_vertices - src_roomoffset; + uintptr_t vtx_ptr = dest_roomblock->ptr_vertices - src_ofs; if (vtx_ptr < endpos) endpos = vtx_ptr; } else if (src_roomblock->ptr_gdl) { - gdls_addr[numgdls++] = srctoh32(src_roomblock->ptr_gdl) - src_roomoffset; + gdls_addr[numgdls++] = srctoh32(src_roomblock->ptr_gdl) - src_ofs; } curpos_src += sizeof(struct n64_roomblock); @@ -415,7 +407,7 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint // block coords for (size_t i = 0; i < ncoords; i++) { - uint32_t *src_coord = (uint32_t*)(src_roomgfxdata + curpos_src); + uint32_t *src_coord = (uint32_t*)(src + curpos_src); uint32_t *dst_coord = (uint32_t*)(dst + curpos_dst); dst_coord[0] = srctoh32(src_coord[0]); @@ -426,7 +418,7 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint dst_coord[4] = srctoh32(src_coord[4]); dst_coord[5] = srctoh32(src_coord[5]); - add_marker(curpos_src + src_roomoffset, curpos_dst + dst_roomoffset); + add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); curpos_src += 6 * sizeof(uint32_t); curpos_dst += 6 * sizeof(uint32_t); @@ -435,16 +427,15 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint curpos_dst = ALIGN8(curpos_dst); // vertices - uintptr_t ptr_src_vertices = curpos_src = ALIGN8(dst_header->ptr_vertices - src_roomoffset); + uintptr_t ptr_src_vertices = curpos_src = ALIGN8(dst_header->ptr_vertices - src_ofs); uintptr_t ptr_dst_vertices = curpos_dst + dst_roomoffset; - add_marker(curpos_src + src_roomoffset, curpos_dst + dst_roomoffset); + add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - uintptr_t vtx_end = dst_header->ptr_colours - src_roomoffset; - vtx_end = dst_header->ptr_colours == 0 ? infsize : vtx_end; - - while (curpos_src < vtx_end) { - struct vtx *src_vtx = (struct vtx*)(src_roomgfxdata + curpos_src); + uintptr_t vtx_end = dst_header->ptr_colours - src_ofs; + + while (dst_header->ptr_colours && curpos_src < vtx_end) { + struct vtx *src_vtx = (struct vtx*)(src + curpos_src); struct vtx *dst_vtx = (struct vtx*)(dst + curpos_dst); dst_vtx->coord[0] = srctoh16(src_vtx->coord[0]); @@ -452,7 +443,7 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint dst_vtx->coord[2] = srctoh16(src_vtx->coord[2]); dst_vtx->flag = src_vtx->flag; - dst_vtx->color= src_vtx->color; + dst_vtx->color = src_vtx->color; dst_vtx->s = srctoh16(src_vtx->s); dst_vtx->t = srctoh16(src_vtx->t); @@ -468,15 +459,15 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint uintptr_t ptr_dst_colors = 0; if (dst_header->ptr_colours) { - ptr_src_colors = curpos_src = ALIGN8(dst_header->ptr_colours - src_roomoffset); + ptr_src_colors = curpos_src = ALIGN8(dst_header->ptr_colours - src_ofs); ptr_dst_colors = curpos_dst + dst_roomoffset; - add_marker(curpos_src + src_roomoffset, curpos_dst + dst_roomoffset); - + add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + uintptr_t col_end = numgdls > 0 != 0 ? gdls_addr[0] : infsize; size_t col_len = col_end - curpos_src; - memcpy(dst + curpos_dst, src_roomgfxdata + curpos_src, col_len); + memcpy(dst + curpos_dst, src + curpos_src, col_len); curpos_src += col_len; curpos_dst += col_len; } @@ -488,8 +479,8 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint m_SizeGDLs = 0; uintptr_t gdlstart = curpos_dst; for (size_t i = 0; i < numgdls; i++) { - add_marker(gdls_addr[i] + src_roomoffset, curpos_dst + dst_roomoffset); - curpos_dst = gbi_convert_gdl(dst, curpos_dst, src_roomgfxdata, gdls_addr[i], 1); + add_marker(gdls_addr[i] + src_ofs, curpos_dst + dst_roomoffset); + curpos_dst = gbi_convert_gdl(dst, curpos_dst, src, gdls_addr[i], 1); } m_SizeGDLs = curpos_dst - gdlstart; @@ -501,8 +492,8 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint if (block->type == BLOCK_LEAF) { relink_ptr(&block->ptr_gdl); - uint32_t offset_vtx = block->ptr_vertices - ptr_src_vertices - src_roomoffset; - uint32_t offset_col = block->ptr_colours - ptr_src_colors - src_roomoffset; + uint32_t offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; + uint32_t offset_col = block->ptr_colours - ptr_src_colors - src_ofs; block->ptr_vertices = ptr_dst_vertices + offset_vtx; block->ptr_colours = ptr_dst_colors + offset_col; @@ -519,122 +510,40 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint32_t dstpos, uint relink_ptr(&dst_header->ptr_opablocks); relink_ptr(&dst_header->ptr_xlublocks); - free(src_roomgfxdata); return curpos_dst; } -static uint32_t convert_section1(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, struct fileheader *n64_header) +static uint32_t convert_section1(uint8_t *dst, uint8_t *src, uint32_t ofs) { - struct fileheader *host_header = (struct fileheader *) &dst[dstpos]; - dstpos += sizeof(*host_header); - - // Unzip primary - size_t infsize = srctoh32(n64_header->primary_infsize); - uint8_t *srcbin = calloc(1, infsize); - uint8_t *dstbin = calloc(1, infsize * 2); - uint32_t srcbinpos = 0; - uint32_t dstbinpos = 0; - - int ret = rzip_inflate(srcbin, infsize, &src[srcpos], srctoh32(n64_header->primary_cmpsize)); - - if (ret < 0) { - fprintf(stderr, "Unable to inflate BG primary data: %d\n", ret); - exit(EXIT_FAILURE); - } - // Convert primary - struct host_primaryheader *host_primary_header = (struct host_primaryheader *) &dstbin[dstbinpos]; - struct n64_primaryheader *n64_primary_header = (struct n64_primaryheader *) &srcbin[srcbinpos]; - srcbinpos += sizeof(struct n64_primaryheader); - dstbinpos += sizeof(*host_primary_header); + uint32_t srcpos = 0; + uint32_t dstpos = 0; + struct host_primaryheader *host_primary_header = (struct host_primaryheader *) dst; + struct n64_primaryheader *n64_primary_header = (struct n64_primaryheader *) src; + srcpos += sizeof(struct n64_primaryheader); + dstpos += sizeof(*host_primary_header); - uint32_t src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - 0x0f000000; + uint32_t src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - ofs; host_primary_header->unused1 = 0; host_primary_header->unused2 = 0; - host_primary_header->ptr_rooms = dstbinpos + 0x0f000000; - convert_primary_rooms(dstbin, &dstbinpos, srcbin, &srcbinpos); + host_primary_header->ptr_rooms = dstpos + ofs; + convert_primary_rooms(dst, &dstpos, src, &srcpos); if (n64_primary_header->ptr_lights) { - host_primary_header->ptr_lights = dstbinpos + 0x0f000000; - srcbinpos = srctodst32(n64_primary_header->ptr_lights) - 0x0f000000; - convert_primary_lights(dstbin, &dstbinpos, srcbin, &srcbinpos, src_bgcmds); + host_primary_header->ptr_lights = dstpos + ofs; + srcpos = srctodst32(n64_primary_header->ptr_lights) - ofs; + convert_primary_lights(dst, &dstpos, src, &srcpos, src_bgcmds); } - host_primary_header->ptr_portals = dstbinpos + 0x0f000000; - srcbinpos = srctodst32(n64_primary_header->ptr_portals) - 0x0f000000; + host_primary_header->ptr_portals = dstpos + ofs; + srcpos = srctodst32(n64_primary_header->ptr_portals) - ofs; uint32_t src_portalvtxs, dst_portalvtxs; - convert_primary_portals(dstbin, &dstbinpos, srcbin, &srcbinpos, &src_portalvtxs, &dst_portalvtxs); + convert_primary_portals(dst, &dstpos, src, &srcpos, &src_portalvtxs, &dst_portalvtxs); - host_primary_header->ptr_bgcmds = dstbinpos + 0x0f000000; - srcbinpos = src_bgcmds; - convert_primary_bgcmds(dstbin, &dstbinpos, srcbin, &srcbinpos, dst_portalvtxs, src_portalvtxs); - - // Convert room gfxdata - uint32_t n64_primary_diff = srctoh32(n64_header->primary_infsize) - srctoh32(n64_header->primary_cmpsize) - 0xc; - struct n64_room *n64_rooms = (struct n64_room *) &srcbin[sizeof(struct n64_primaryheader)]; - struct host_room *host_rooms = (struct host_room *) &dstbin[sizeof(struct host_primaryheader)]; - - uint8_t *roomgfxbuf = calloc(1, (size_t)1024 * 1024); - uint8_t *allcmp = calloc(1, (size_t)1024 * 1024); - int cmppos = 0; - - host_rooms[0].ptr_gfxdata = 0; - for (int i = 1; i <= m_NumRooms; i++) { - host_rooms[i].ptr_gfxdata = dstbinpos + cmppos + 0x0f000000; - - if (i == m_NumRooms) break; - - uint32_t gfxdatacompsize = srctoh32(n64_rooms[i + 1].ptr_gfxdata) - srctoh32(n64_rooms[i].ptr_gfxdata); - srcpos = srctoh32(n64_rooms[i].ptr_gfxdata) - n64_primary_diff - 0x0f000000; - uint32_t src_roomoffset = srctoh32(n64_rooms[i].ptr_gfxdata); - uint32_t roomgfxbufpos = convert_section1_roomgfxdata(roomgfxbuf, 0, src+srcpos, gfxdatacompsize, src_roomoffset, dstbinpos + cmppos); - - size_t ziplen = 0; - ret = rzip_deflate(&allcmp[cmppos], &ziplen, roomgfxbuf, roomgfxbufpos); - if (ret < 0) { - fprintf(stderr, "Unable to compress BG roomgfxdata for room 0x%x: %d\n", i, ret); - exit(EXIT_FAILURE); - } - - ziplen = ALIGN16(ziplen); - cmppos += ziplen; - - m_AllocSizes[i - 1] = roomgfxbufpos + (ziplen > m_SizeGDLs ? ziplen*4 : m_SizeGDLs*4); - } - - host_rooms[m_NumRooms+1].ptr_gfxdata = 0; - - // Zip primary - size_t ziplen = 0; - - printf("dstbin:%d = %p\n", __LINE__, dstbin); - printf("dstpos:%d = %d\n", __LINE__, dstpos); - printf("dstbinpos:%d = %d\n", __LINE__, dstbinpos); - ret = rzip_deflate(&dst[dstpos], &ziplen, dstbin, dstbinpos); - - if (ret < 0) { - fprintf(stderr, "Unable to compress BG primary data: %d\n", ret); - exit(EXIT_FAILURE); - } - - printf("ziplen:%d = %d\n", __LINE__, ziplen); - ziplen = ALIGN16(ziplen); - dstpos += ziplen; - - // Paste compressed roomgfxdata after it - memcpy(&dst[dstpos], allcmp, cmppos); - dstpos += cmppos; - - free(roomgfxbuf); - free(allcmp); - free(srcbin); - free(dstbin); - - host_header->primary_infsize = dstbinpos; - host_header->section1_cmpsize = ziplen + cmppos; - host_header->primary_cmpsize = ziplen; + host_primary_header->ptr_bgcmds = dstpos + ofs; + convert_primary_bgcmds(dst, &dstpos, &src[src_bgcmds], dst_portalvtxs, src_portalvtxs); return dstpos; } @@ -691,102 +600,36 @@ static void convert_section3_lightcounts(uint8_t *dst, uint32_t *dstpos, uint8_t *dstpos += (m_NumRooms - 1); } -static uint32_t convert_zipped_section(int section_num, uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, struct sectionheader *n64_header) +#ifdef PLATFORM_64BIT +void preprocessBgSection1(uint8_t *data, uint32_t size, uint32_t ofs) { - struct sectionheader *host_header = (struct sectionheader *) &dst[dstpos]; - dstpos += sizeof(*host_header); + uint8_t *dst = sysMemZeroAlloc(size); - // Unzip - size_t infsize = rzip_get_infsize(&src[srcpos]); - uint8_t *srcbin = calloc(1, infsize); - uint8_t *dstbin = calloc(1, infsize); - uint32_t srcbinpos = 0; - uint32_t dstbinpos = 0; + uint32_t newSize = convert_section1(dst, data, ofs); - int ret = rzip_inflate(srcbin, infsize, &src[srcpos], srctoh16(n64_header->cmpsize)); - - if (ret < 0) { - fprintf(stderr, "Unable to inflate BG section %d: %d\n", section_num, ret); + if (newSize > size) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg file, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); } - // Convert - if (section_num == 2) { - convert_section2_texturenums(dstbin, &dstbinpos, srcbin, &srcbinpos, infsize); - } else if (section_num == 3) { - convert_section3_bboxes(dstbin, &dstbinpos, srcbin, &srcbinpos); - convert_section3_allocsizes(dstbin, &dstbinpos, srcbin, &srcbinpos); - convert_section3_lightcounts(dstbin, &dstbinpos, srcbin, &srcbinpos); - } + memcpy(data, dst, newSize); + sysMemFree(dst); +} - // Zip - size_t ziplen = 0; +uint32_t preprocessBgRoom(uint8_t *data, uint32_t size, uint32_t room_ofs) +{ + size *= 2; + uint8_t *dst = sysMemZeroAlloc(size); + uint32_t newSize = convert_section1_roomgfxdata(dst, data, size, room_ofs); - ret = rzip_deflate(&dst[dstpos], &ziplen, dstbin, dstbinpos); - - if (ret < 0) { - fprintf(stderr, "Unable to compress BG section %d: %d\n", section_num, ret); + if (newSize > size) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg room, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); } - ziplen = ALIGN16(ziplen); + memcpy(data, dst, newSize); + sysMemFree(dst); - host_header->infsize = dstbinpos; - host_header->cmpsize = ziplen; - - dstpos += ziplen; - - free(srcbin); - free(dstbin); - - return dstpos; -} - -void extract_file_bg(char *filename, uint32_t romoffset, size_t len) -{ - if (0) { - if (strcmp(filename, "bgdata/bg_mp5.seg") != 0) { - return; - } - } - - if (strcmp(filename, "ob/ob_mid.seg") == 0) { - return; - } - - size_t dstlen = len * 2; - uint8_t *dst = calloc(1, dstlen); - uint32_t dstpos = 0; - m_NumPtrMarkers = 0; - m_SizeGDLs = 0; - gbi_reset(); - - printf("--------------------------------------------------------------------------------\n"); - printf("-- %s\n", filename); - - uint8_t *src = &g_Rom[romoffset]; - struct fileheader *n64_fileheader = (struct fileheader *) src; - uint32_t n64_section2_start = sizeof(*n64_fileheader) + srctoh32(n64_fileheader->section1_cmpsize); - struct sectionheader *n64_section2header = (struct sectionheader *) &src[n64_section2_start]; - uint32_t n64_section3_start = n64_section2_start + sizeof(*n64_section2header) + (srctoh16(n64_section2header->cmpsize) & 0x7fff); - struct sectionheader *n64_section3header = (struct sectionheader *) &src[n64_section3_start]; - - printf("section2_start 0x%x\n", n64_section2_start); - printf("section3_start 0x%x\n", n64_section3_start); - - dstpos = convert_section1(dst, dstpos, src, sizeof(*n64_fileheader), n64_fileheader); - dstpos = convert_zipped_section(2, dst, dstpos, src, n64_section2_start + sizeof(*n64_section2header), n64_section2header); - dstpos = convert_zipped_section(3, dst, dstpos, src, n64_section3_start + sizeof(*n64_section3header), n64_section3header); - dstpos = ALIGN16(dstpos); - - sysLogPrintf(LOG_NOTE, "%s %d %d %.3f", filename, len, dstpos, (f32)dstpos / len); - - char outfilename[1024]; - sprintf(outfilename, "%s/files/%s", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(dst, dstpos, 1, fp); - fclose(fp); - - free(dst); + return newSize; } +#endif \ No newline at end of file diff --git a/port/pdextract/ext_file_lang.c b/port/pdextract/ext_file_lang.c index 471cba49e..9764c3a24 100644 --- a/port/pdextract/ext_file_lang.c +++ b/port/pdextract/ext_file_lang.c @@ -2,6 +2,7 @@ #include #include #include "common.h" +#include "system.h" static int get_next_nonzero(uint8_t *src, uint32_t offset, size_t len) { @@ -30,28 +31,16 @@ static int get_num_strings(uint8_t *src, size_t len) return 1; } -void extract_file_lang(char *filename, uint32_t romoffset, size_t srclen) +uint32_t convert_lang_file(uint8_t *dst, uint8_t *src, size_t srclen) { - // Unzip it - size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); - uint8_t *src = malloc(infsize); - - int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], srclen); - - if (ret < 0) { - fprintf(stderr, "%s: Unable to inflate file: %d\n", filename, ret); - exit(EXIT_FAILURE); - } - // Convert it uint32_t *src_offsets = (uint32_t *) src; size_t src_ptr_table_len = srctoh32(src_offsets[0]); - size_t src_str_table_len = infsize - src_ptr_table_len; + size_t src_str_table_len = srclen - src_ptr_table_len; int num_strings = get_num_strings(src, srclen); size_t dst_ptr_table_len = num_strings * sizeof(uintptr_t); size_t dst_str_table_len = src_str_table_len; - uint8_t *dst = calloc(1, dst_ptr_table_len + dst_str_table_len + 0x20); int cur_dst_offset = dst_ptr_table_len; uintptr_t *dst_offsets = (uintptr_t *) dst; @@ -67,7 +56,7 @@ void extract_file_lang(char *filename, uint32_t romoffset, size_t srclen) uint32_t end = get_next_nonzero(src, (i + 1) * 4, num_strings * 4); if (!end) { - end = infsize; + end = srclen; } size_t len = end - src_offset; @@ -81,30 +70,24 @@ void extract_file_lang(char *filename, uint32_t romoffset, size_t srclen) } } - cur_dst_offset = ALIGN16(cur_dst_offset); + return ALIGN16(cur_dst_offset); +} - // Zip it - uint8_t *zipped = calloc(1, cur_dst_offset); - size_t ziplen = cur_dst_offset; +uint8_t *preprocessLangFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) { + uint32_t newSizeEstimated = (uint32_t)(size * 1.3); + uint8_t *dst = sysMemZeroAlloc(newSizeEstimated); - ret = rzip_deflate(zipped, &ziplen, dst, cur_dst_offset); + uint32_t newSize = convert_lang_file(dst, data, size); - if (ret < 0) { - fprintf(stderr, "%s: Unable to compress file: %d\n", filename, ret); + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a lang file, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); } - ziplen = ALIGN16(ziplen); + memcpy(data, dst, newSize); + sysMemFree(dst); - // Write it - char outfilename[1024]; - sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + *outSize = newSize; - FILE *fp = openfile(outfilename); - fwrite(zipped, ziplen, 1, fp); - fclose(fp); - - free(zipped); - free(dst); - free(src); + return 0; } diff --git a/port/pdextract/ext_file_model.c b/port/pdextract/ext_file_model.c index 3a91748c8..aa8e29321 100644 --- a/port/pdextract/ext_file_model.c +++ b/port/pdextract/ext_file_model.c @@ -4,11 +4,6 @@ #include "common.h" #include "system.h" -#include - -#undef near -#undef far - enum contenttype { /* 0*/ CT_MODELDEF, /* 1*/ CT_NODE, @@ -923,21 +918,6 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) } } -int calc_align(uint32_t value) -{ - if ((value % 16) == 0) { - return 16; - } else if ((value % 8) == 0) { - return 8; - } else if ((value % 4) == 0) { - return 4; - } else if ((value % 2) == 0) { - return 2; - } else { - return 1; - } -} - static int convert_model(uint8_t *dst, uint8_t *src, uint32_t srclen) { uint32_t dstpos; @@ -951,54 +931,24 @@ static int convert_model(uint8_t *dst, uint8_t *src, uint32_t srclen) return dstpos; } -void extract_file_model(char *filename, uint32_t romoffset, size_t len) +uint8_t *preprocessModelFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) { gbi_reset(); - // Unzip it - size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); - uint8_t *src = malloc(infsize); - int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); + uint32_t newSizeEstimated = (uint32_t)(size * 1.7); + uint8_t *dst = sysMemZeroAlloc(newSizeEstimated); - if (ret < 0) { - fprintf(stderr, "%s: Unable to inflate file: %d\n", filename, ret); + uint32_t newSize = convert_model(dst, data, size); + + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); } - // Convert it - uint8_t *dst = calloc(1, infsize * 2); + memcpy(data, dst, newSize); + sysMemFree(dst); - int dstpos = convert_model(dst, src, infsize); + *outSize = newSize; - if (dstpos > infsize * 2) { - fprintf(stderr, "%s: overflow\n", filename); - exit(EXIT_FAILURE); - } - - // Zip it - uint8_t *zipped = calloc(1, dstpos); - size_t ziplen = dstpos; - - ret = rzip_deflate(zipped, &ziplen, dst, dstpos); - - if (ret < 0) { - fprintf(stderr, "%s: Unable to compress file: %d\n", filename, ret); - exit(EXIT_FAILURE); - } - - ziplen = ALIGN16(ziplen); - - // Write it - char outfilename[1024]; - sprintf(outfilename, "%s/files/%s", g_OutPath, filename); - - sysLogPrintf(LOG_NOTE, "%s %d %d %.3f", filename, infsize, dstpos, (f32)dstpos/infsize); - - FILE *fp = openfile(outfilename); - fwrite(zipped, ziplen, 1, fp); - fclose(fp); - - free(zipped); - free(dst); - free(src); + return 0; } diff --git a/port/pdextract/ext_file_pads.c b/port/pdextract/ext_file_pads.c index db642dc22..46bfa7187 100644 --- a/port/pdextract/ext_file_pads.c +++ b/port/pdextract/ext_file_pads.c @@ -2,6 +2,7 @@ #include #include #include "common.h" +#include "system.h" #define PADFLAG_INTPOS 0x0001 #define PADFLAG_UPALIGNTOX 0x0002 @@ -276,7 +277,7 @@ static int convert_cover(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int return dstpos; } -static int convert_binary(uint8_t *dst, uint8_t *src) +static int convert_pads_file(uint8_t *dst, uint8_t *src) { int dstpos = 0; struct n64_header *n64_header = (struct n64_header *) src; @@ -307,45 +308,21 @@ static int convert_binary(uint8_t *dst, uint8_t *src) return dstpos; } -void extract_file_pads(char *filename, uint32_t romoffset, size_t len) -{ - // Unzip it - size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); - uint8_t *src = malloc(infsize); +u8* preprocessPadsFile_x64(u8 *data, u32 size, u32 *outSize) { + u32 newSizeEstimated = (u32)(size * 1.7); + u8* dst = sysMemZeroAlloc(newSizeEstimated); - int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); + u32 newSize = convert_pads_file(dst, data); - if (ret < 0) { - fprintf(stderr, "%s: Unable to inflate file: %d\n", filename, ret); + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a pads file, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); } - // Convert it - uint8_t *dst = calloc(1, infsize * 2); - int dstpos = convert_binary(dst, src); + memcpy(data, dst, newSize); + sysMemFree(dst); - dstpos = ALIGN16(dstpos); + *outSize = newSize; - // Zip it - uint8_t *zipped = calloc(1, dstpos); - size_t ziplen = dstpos; - - ret = rzip_deflate(zipped, &ziplen, dst, dstpos); - - if (ret < 0) { - fprintf(stderr, "%s: Unable to compress file: %d\n", filename, ret); - exit(EXIT_FAILURE); - } - - // Write it - char outfilename[1024]; - sprintf(outfilename, "%s/files/%s", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(zipped, ALIGN16(ziplen), 1, fp); - fclose(fp); - - free(src); - free(dst); - free(zipped); + return 0; } diff --git a/port/pdextract/ext_file_tiles.c b/port/pdextract/ext_file_tiles.c index 772bccb5c..4c2bf6b76 100644 --- a/port/pdextract/ext_file_tiles.c +++ b/port/pdextract/ext_file_tiles.c @@ -2,6 +2,8 @@ #include #include #include "common.h" +#include "system.h" + struct tile { uint8_t type; @@ -17,19 +19,8 @@ struct tile { uint16_t floorcol; }; -void extract_file_tiles(char *filename, uint32_t romoffset, size_t len) +uint32_t convert_tiles(uint8_t *dst, uint8_t *src, size_t srclen) { - // Unzip it - size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); - uint8_t *src = malloc(infsize); - - int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); - - if (ret < 0) { - fprintf(stderr, "%s: Unable to inflate file: %d\n", filename, ret); - exit(EXIT_FAILURE); - } - int num_rooms = srctoh32(*(uint32_t *) src); size_t src_ptr_table_len = (num_rooms + 1) * 4; @@ -37,13 +28,11 @@ void extract_file_tiles(char *filename, uint32_t romoffset, size_t len) uint32_t *src_offsets = (uint32_t *) &src[4]; - size_t data_len = infsize - src_ptr_table_len - 4; - - uint8_t *dst = calloc(1, dst_ptr_table_len + data_len + 0x20); + size_t data_len = srclen - src_ptr_table_len - 4; *(uint32_t *) dst = htodst32(num_rooms); - uint32_t*dst_offsets = (uint32_t*) (dst + sizeof(uint32_t)); + uint32_t *dst_offsets = (uint32_t *) (dst + sizeof(uint32_t)); uint32_t cur_dst_offset = dst_ptr_table_len + sizeof(uint32_t); uint32_t cur_src_offset = srctoh32(src_offsets[0]); @@ -92,31 +81,24 @@ void extract_file_tiles(char *filename, uint32_t romoffset, size_t len) } } - cur_dst_offset = ALIGN16(cur_dst_offset); + return ALIGN16(cur_dst_offset); +} - // Zip it - uint8_t *zipped = calloc(1, cur_dst_offset); - size_t ziplen = cur_dst_offset; +uint8_t *preprocessTilesFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) +{ + uint8_t *dst = sysMemZeroAlloc(size); - ret = rzip_deflate(zipped, &ziplen, dst, cur_dst_offset); + uint32_t newSize = convert_tiles(dst, data, size); - if (ret < 0) { - fprintf(stderr, "%s: Unable to compress file: %d\n", filename, ret); + if (newSize > size) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a tiles file, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); } - ziplen = ALIGN16(ziplen); + memcpy(data, dst, newSize); + sysMemFree(dst); - // Write it - char outfilename[1024]; + *outSize = newSize; - sprintf(outfilename, "%s/files/%s", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(zipped, ziplen, 1, fp); - fclose(fp); - - free(zipped); - free(dst); - free(src); + return 0; } diff --git a/port/pdextract/ext_files.c b/port/pdextract/ext_files.c deleted file mode 100644 index 9f64e5031..000000000 --- a/port/pdextract/ext_files.c +++ /dev/null @@ -1,100 +0,0 @@ -#include -#include -#include -#include "common.h" - -void extract_file_audio(char *filename, uint32_t romoffset, size_t len); -void extract_file_bg(char *filename, uint32_t romoffset, size_t len); -void extract_file_lang(char *filename, uint32_t romoffset, size_t len); -void extract_file_model(char *filename, uint32_t romoffset, size_t len); -void extract_file_pads(char *filename, uint32_t romoffset, size_t len); -void extract_file_tiles(char *filename, uint32_t romoffset, size_t len); - -static void extract_file(int filenum, uint32_t romoffset, size_t len) -{ - uint32_t name_uint32_table = 0; - - switch (g_RomVersion) { - case ROMVERSION_NTSC10: - case ROMVERSION_NTSCFINAL: - name_uint32_table = 0x1d5ca00; - break; - case ROMVERSION_PALFINAL: - name_uint32_table = 0x1d534e0; - break; - case ROMVERSION_JPNFINAL: - name_uint32_table = 0x1d58a20; - break; - } - - uint32_t name_offset = name_uint32_table + srctoh32(*(uint32_t *) &g_Rom[name_uint32_table + filenum * 4]); - - char *filename = (char *) &g_Rom[name_offset]; - - if (strstr(filename, ".seg")) { - extract_file_bg(filename, romoffset, len); - } else if (strstr(filename, "padsZ")) { - extract_file_pads(filename, romoffset, len); - } else if (strstr(filename, "tilesZ")) { - extract_file_tiles(filename, romoffset, len); - } else if (filename[0] == 'A') { - extract_file_audio(filename, romoffset, len); - } else if (filename[0] == 'C' || filename[0] == 'G' || filename[0] == 'P') { - extract_file_model(filename, romoffset, len); - } else if (filename[0] == 'L') { - extract_file_lang(filename, romoffset, len); - } else if (filename[0] == 'U') { - // Setup file - don't extract - } else { - fprintf(stderr, "Unrecognised file type: '%s'\n", filename); - exit(EXIT_FAILURE); - } -} - -void extract_files(void) -{ - size_t infsize = rzip_get_infsize(&g_Rom[0x39850]); - uint8_t *data = malloc(infsize); - - int ret = rzip_inflate(data, infsize, &g_Rom[0x39850], infsize); - - if (ret < 0) { - fprintf(stderr, "Unable to inflate data segment: %d\n", ret); - exit(EXIT_FAILURE); - } - - uint32_t offset = 0; - - switch (g_RomVersion) { - case ROMVERSION_NTSC10: - case ROMVERSION_NTSCFINAL: - offset = 0x28080; - break; - case ROMVERSION_PALFINAL: - offset = 0x28910; - break; - case ROMVERSION_JPNFINAL: - offset = 0x28800; - break; - } - - uint32_t *offsets = (uint32_t *) &data[offset]; - int i = 0; - - while (1) { - uint32_t curr = srctoh32(offsets[i]); - uint32_t next = srctoh32(offsets[i + 1]); - - if (next == 0) { - break; - } - - if (curr) { - extract_file(i, curr, next - curr); - } - - i++; - } - - free(data); -} diff --git a/port/pdextract/ext_fonts.c b/port/pdextract/ext_fonts.c index c7a9bd7c0..eddddedff 100644 --- a/port/pdextract/ext_fonts.c +++ b/port/pdextract/ext_fonts.c @@ -4,6 +4,7 @@ #include #include #include "common.h" +#include "system.h" struct n64fontchar { uint8_t index; @@ -41,15 +42,33 @@ struct hostfontcharjpn { uintptr_t pixeldata; }; -static void extract_font(const char *filename, uint32_t romoffset, size_t srclen, int num_chars) +struct fontdef { + const char *name; + uint32_t offsets[3]; + int pal_extra_chars; +}; + +u8* preprocessFont_x64(u8 *src, u32 srclen, u32 *outSize) { + int num_chars = 94; +#if VERSION == VERSION_PAL_FINAL + // PAL has more characters in these fonts + extern u8* _fonthandelgothicsmSegmentRomStart; + extern u8* _fonthandelgothicxsSegmentRomStart; + extern u8* _fonthandelgothicmdSegmentRomStart; + if (src == _fonthandelgothicsmSegmentRomStart + || src == _fonthandelgothicxsSegmentRomStart + || src == _fonthandelgothicmdSegmentRomStart) { + numchars = 135; + } +#endif + size_t dstlen = srclen - (num_chars * sizeof(struct n64fontchar)) + (num_chars * sizeof(struct hostfontchar)) + 0x20; - uint8_t *src = &g_Rom[romoffset]; - uint8_t *dst = calloc(1, dstlen); + uint8_t* dst = sysMemZeroAlloc(dstlen); // Kerning table - int32_t *src_kerning_table = (int32_t *) src; - int32_t *dst_kerning_table = (int32_t *) dst; + int32_t *src_kerning_table = (int32_t *)src; + int32_t *dst_kerning_table = (int32_t *)dst; for (int i = 0; i < 13 * 13; i++) { dst_kerning_table[i] = srctodst32(src_kerning_table[i]); @@ -59,7 +78,7 @@ static void extract_font(const char *filename, uint32_t romoffset, size_t srclen uint32_t dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); // Character table - if (g_RomVersion == ROMVERSION_JPNFINAL) { +#if VERSION == VERSION_JPN_FINAL struct n64fontcharjpn *src_char_table = (struct n64fontcharjpn *) &src[src_offset]; struct hostfontcharjpn *dst_char_table = (struct hostfontcharjpn *) &dst[dst_offset]; uint32_t diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); @@ -75,7 +94,7 @@ static void extract_font(const char *filename, uint32_t romoffset, size_t srclen src_offset += num_chars * sizeof(struct n64fontcharjpn); dst_offset += num_chars * sizeof(struct hostfontcharjpn); - } else { +#else struct n64fontchar *src_char_table = (struct n64fontchar *) &src[src_offset]; struct hostfontchar *dst_char_table = (struct hostfontchar *) &dst[dst_offset]; uint32_t diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); @@ -91,67 +110,13 @@ static void extract_font(const char *filename, uint32_t romoffset, size_t srclen src_offset += num_chars * sizeof(struct n64fontchar); dst_offset += num_chars * sizeof(struct hostfontchar); - } +#endif // Pixel data - size_t len = srclen - src_offset; - + u32 len = srclen - src_offset; memcpy(&dst[dst_offset], &src[src_offset], len); - dst_offset = ALIGN16(dst_offset + len); + if (outSize) *outSize = ALIGN16(dst_offset + len); - // Write it - char outfilename[1024]; - sprintf(outfilename, "%s/segs/font%s", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(dst, dst_offset, 1, fp); - fclose(fp); - - free(dst); -} - -struct fontdef { - const char *name; - uint32_t offsets[3]; - int pal_extra_chars; -}; - -void extract_fonts(void) -{ - struct fontdef defs[] = { - // ntsc pal jpn - {"bankgothic", {0x7f2390, 0x7ddb90, 0x7e1a20}, 0}, - {"zurich", {0x7f4930, 0x7e0130, 0x7e3fc0}, 0}, - {"tahoma", {0x7f7860, 0x7e3060, 0x7e6ef0}, 0}, - {"numeric", {0x7f8b20, 0x7e4320, 0x7e81b0}, 0}, - {"handelgothicsm", {0x7f9d30, 0x7e5530, 0x7e93c0}, 1}, - {"handelgothicxs", {0x7fbfb0, 0x7e87b0, 0x7ec640}, 1}, - {"handelgothicmd", {0x7fdd80, 0x7eae20, 0x7eecb0}, 1}, - {"handelgothiclg", {0x8008e0, 0x7eee70, 0x7f2d00}, 0}, - {"ocramd", {0x803da0, 0x7f2330, 0x7f61c0}, 0}, - {"ocralg", {0x806ac0, 0x7f5050, 0x7f8ee0}, 0}, - {"end", {0x80a250, 0x7f87e0, 0x7fc670}, 0}, - }; - - int index = 0; - - switch (g_RomVersion) { - case ROMVERSION_NTSC10: - case ROMVERSION_NTSCFINAL: - index = 0; - break; - case ROMVERSION_PALFINAL: - index = 1; - break; - case ROMVERSION_JPNFINAL: - index = 2; - break; - } - - for (int i = 0; i < ARRAYCOUNT(defs) - 1; i++) { - int num_chars = g_RomVersion == ROMVERSION_PALFINAL && defs[i].pal_extra_chars ? 135 : 94; - size_t len = defs[i + 1].offsets[index] - defs[i].offsets[index]; - extract_font(defs[i].name, defs[i].offsets[index], len, num_chars); - } + return dst; } diff --git a/port/pdextract/ext_jpnfonts.c b/port/pdextract/ext_jpnfonts.c deleted file mode 100644 index 02d04c67a..000000000 --- a/port/pdextract/ext_jpnfonts.c +++ /dev/null @@ -1,32 +0,0 @@ -#include -#include -#include -#include "common.h" - -static void extract_jpnfont(const char *filename, uint32_t romoffset, size_t len) -{ - char outfilename[1024]; - sprintf(outfilename, "%s/segs/%s", g_OutPath, filename); - - FILE *fp = openfile(outfilename); - fwrite(&g_Rom[romoffset], len, 1, fp); - fclose(fp); -} - -void extract_jpnfonts(void) -{ - switch (g_RomVersion) { - case ROMVERSION_NTSC10: - case ROMVERSION_NTSCFINAL: - extract_jpnfont("fontjpnsingle", 0x194440, 0xb020); - extract_jpnfont("fontjpnmulti", 0x19fb40, 0x1a80); - break; - case ROMVERSION_PALFINAL: - extract_jpnfont("fontjpnsingle", 0x17fc40, 0xb010); - extract_jpnfont("fontjpnmulti", 0x18b340, 0x1a80); - break; - case ROMVERSION_JPNFINAL: - extract_jpnfont("fontjpn", 0x178c40, 0x17920); - break; - } -} diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c index ea8745e72..9f0316370 100644 --- a/port/pdextract/ext_setups.c +++ b/port/pdextract/ext_setups.c @@ -2,21 +2,21 @@ #include #include +#include "types.h" + #include "common.h" #include "system.h" #include "assert.h" #include "setups_decl.h" -#include "types.h" -static inline f32 convF32(f32 *dst, f32 src) { *(u32*)dst = srctoh32(*(u32*)&src); } -static inline u32 convU32(u32 *dst, u32 src) { *dst = srctoh32(src); } -static inline s32 convS32(s32 *dst, s32 src) { *dst = srctoh32(src); } -static inline u16 convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } -static inline s16 convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } -static inline u8 cpyByte(u8 *dst, u8 src) { *dst = src; } -static inline void* convPtr(void** dst, u32 src) { *dst = srctoh32(src); } -static inline struct coord convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } +static inline void convF32(f32 *dst, f32 src) { *(u32*)dst = srctoh32(*(u32*)&src); } +static inline void convU32(u32 *dst, u32 src) { *dst = srctoh32(src); } +static inline void convS32(s32 *dst, s32 src) { *dst = srctoh32(src); } +static inline void convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } +static inline void convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } +static inline void cpyByte(u8 *dst, u8 src) { *dst = src; } +static inline void convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } static u32 convUnk(void* x, u32 y) { __debugbreak(); } #define PD_CONV_VAL(dst, src) _Generic((dst), \ @@ -1231,54 +1231,21 @@ void test_conv_functions() PD_CONV_ARRAY2D(dst8, src8); } -void extract_file_setups(char* filename, u32 romoffset, size_t len) -{ - // Unzip it - size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); - u8* src = malloc(infsize); +u8 *preprocessSetupFile_x64(u8 *data, u32 size, u32 *outSize) { + u32 newSizeEstimated = (u32)(size * 3.3); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); - int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); + u32 newSize = convert_setup(dst, data, size); - if (ret < 0) { - sysLogPrintf(LOG_ERROR, "%s: Unable to inflate file: %d", filename, ret); + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a model file, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); } - // Convert it - u8* dst = calloc(1, infsize * 4); + memcpy(data, dst, newSize); + sysMemFree(dst); - int* mark = strstr(filename, "mp_setupdam"); - u32 dstpos = convert_setup(dst, src, infsize); + *outSize = newSize; - if (dstpos > infsize * 4) { - sysLogPrintf(LOG_ERROR, "%s: overflow", filename); - exit(EXIT_FAILURE); - } - - sysLogPrintf(LOG_NOTE, "%s %d %d %.3f", filename, infsize, dstpos, (f32)dstpos / infsize); - - // Zip it - u8* zipped = calloc(1, dstpos); - size_t ziplen = dstpos; - - ret = rzip_deflate(zipped, &ziplen, dst, dstpos); - - if (ret < 0) { - sysLogPrintf(LOG_ERROR, "%s: Unable to compress file: %d", filename, ret); - exit(EXIT_FAILURE); - } - - ziplen = ALIGN16(ziplen); - - // Write it - char outfilename[1024]; - sprintf(outfilename, "%s/files/%s", g_OutPath, filename); - - FILE* fp = openfile(outfilename); - fwrite(zipped, ziplen, 1, fp); - fclose(fp); - - free(zipped); - free(dst); - free(src); -} \ No newline at end of file + return 0; +} diff --git a/port/pdextract/ext_textures.c b/port/pdextract/ext_textures.c deleted file mode 100644 index 74e126163..000000000 --- a/port/pdextract/ext_textures.c +++ /dev/null @@ -1,76 +0,0 @@ -#include -#include -#include -#include "common.h" - -struct texture { - uint32_t soundsurfacetype : 4; - uint32_t surfacetype : 4; - uint32_t dataoffset : 24; - uint32_t unk04; -}; - -static void extract_textures_data(uint32_t romoffset, size_t len) -{ - char outfilename[1024]; - sprintf(outfilename, "%s/textures_data.bin", g_OutPath); - - FILE *fp = openfile(outfilename); - fwrite(&g_Rom[romoffset], len, 1, fp); - fclose(fp); -} - -static void extract_textures_table(uint32_t romoffset, size_t len) -{ - int num_textures = len / sizeof(struct texture); - uint8_t *dst = calloc(1, len); - - struct texture *n64texes = (struct texture *) &g_Rom[romoffset]; - struct texture *hosttexes = (struct texture *) dst; - - for (int i = 0; i < num_textures; i++) { - hosttexes[i].soundsurfacetype = n64texes[i].soundsurfacetype; - hosttexes[i].surfacetype = n64texes[i].surfacetype; - hosttexes[i].dataoffset = srctodst32(n64texes[i].dataoffset); - hosttexes[i].unk04 = 0; - } - - // Write it - char outfilename[1024]; - sprintf(outfilename, "%s/textures_table.bin", g_OutPath); - - FILE *fp = openfile(outfilename); - fwrite(dst, len, 1, fp); - fclose(fp); - - free(dst); -} - -void extract_textures(void) -{ - uint32_t data_offset = 0; - uint32_t table_offset = 0; - uint32_t end = 0; - - switch (g_RomVersion) { - case ROMVERSION_NTSC10: - case ROMVERSION_NTSCFINAL: - data_offset = 0x1d65f40; - table_offset = 0x1ff7ca0; - end = 0x1ffea20; - break; - case ROMVERSION_PALFINAL: - data_offset = 0x1d5ca20; - table_offset = 0x1fee780; - end = 0x1ff5500; - break; - case ROMVERSION_JPNFINAL: - data_offset = 0x1d61f90; - table_offset = 0x1ff68f0; - end = 0x1ffd6b0; - break; - } - - extract_textures_data(data_offset, table_offset - data_offset); - extract_textures_table(table_offset, end - table_offset); -} diff --git a/port/pdextract/main.c b/port/pdextract/main.c deleted file mode 100644 index c5230fe16..000000000 --- a/port/pdextract/main.c +++ /dev/null @@ -1,173 +0,0 @@ -#include -#include -#include -#include -#include "common.h" - -#define ROM_SIZE (1024 * 1024 * 32) - -uint8_t *g_Rom = NULL; -enum romversion g_RomVersion = 0; -char g_OutPath[1024] = {'\0'}; - -void extract_anims(void); -void extract_audio(void); -void extract_banners(void); -void extract_files(void); -void extract_fonts(void); -void extract_jpnfonts(void); -void extract_textures(void); - -/** - * We allow modded ROMs to be used, so we can't simply compare the ROM checksum. - */ -static enum romversion identify_rom_version(uint8_t *rom) -{ - char game_code[5]; - game_code[0] = rom[0x3b]; - game_code[1] = rom[0x3c]; - game_code[2] = rom[0x3d]; - game_code[3] = rom[0x3e]; - game_code[4] = '\0'; - - char version_byte = rom[0x3f]; - - if (strncmp((char *) &rom[0x20], "Perfect Dark DBGNTSC", 20) == 0) { - return ROMVERSION_NTSCBETA; - } - - if (strcmp(game_code, "NPDJ") == 0) { - return ROMVERSION_JPNFINAL; - } - - if (strcmp(game_code, "NPDE") == 0) { - if (version_byte == 1) { - return ROMVERSION_NTSCFINAL; - } - - if (version_byte == 0) { - return ROMVERSION_NTSC10; - } - } - - if (strcmp(game_code, "NPDP") == 0) { - if (rom[0x100f] == 0xe0) { - return ROMVERSION_PALBETA; - } - - if (rom[0x100f] == 0xf0) { - return ROMVERSION_PALFINAL; - } - } - - return ROMVERSION_UNKNOWN; -} - -static void flip_pairs(uint8_t *rom) -{ - uint16_t *ptr = (uint16_t *) rom; - - for (int i = 0; i < ROM_SIZE / 2; i++) { - ptr[i] = __bswap_16(ptr[i]); - } -} - -static void flip_words(uint8_t *rom) -{ - uint32_t *ptr = (uint32_t *) rom; - - for (int i = 0; i < ROM_SIZE / 4; i++) { - ptr[i] = __bswap_32(ptr[i]); - } -} - -static void extract_rom(char *romfile) -{ - FILE *fp = fopen(romfile, "rb"); - - if (fp == NULL) { - fprintf(stderr, "Unable to open '%s' for reading.\n", romfile); - exit(EXIT_FAILURE); - } - - fseek(fp, 0, SEEK_END); - - if (ftell(fp) != ROM_SIZE) { - fprintf(stderr, "The ROM size is not 32MB. Is this a Perfect Dark ROM?\n"); - exit(EXIT_FAILURE); - } - - fseek(fp, 0, SEEK_SET); - - g_Rom = malloc(ROM_SIZE); - fread(g_Rom, 1, ROM_SIZE, fp); - fclose(fp); - - uint32_t magic = (g_Rom[0] << 24) | (g_Rom[1] << 16) | (g_Rom[2] << 8) | g_Rom[3]; - - switch (magic) { - case 0x80371240: - break; - case 0x37804012: - flip_pairs(g_Rom); - break; - case 0x40123780: - flip_words(g_Rom); - break; - default: - fprintf(stderr, "Unable to detect ROM header. Is this an N64 ROM?\n"); - exit(EXIT_FAILURE); - break; - } - - g_RomVersion = identify_rom_version(g_Rom); - - if (g_RomVersion == ROMVERSION_NTSCBETA || g_RomVersion == ROMVERSION_PALBETA) { - fprintf(stderr, "The beta versions are not supported.\n"); - exit(EXIT_FAILURE); - } - - if (g_RomVersion == ROMVERSION_UNKNOWN) { - fprintf(stderr, "Unable to determine your Perfect Dark version. Is this a Perfect Dark ROM?\n"); - exit(EXIT_FAILURE); - } - - extract_anims(); - extract_audio(); - extract_files(); - extract_fonts(); - extract_jpnfonts(); - extract_textures(); - extract_banners(); - - free(g_Rom); - g_Rom = NULL; -} - -int main(int argc, char **argv) -{ - char *romfile = NULL; - - if (argc < 2) { - fprintf(stderr, "Usage: pd-extract [PATH]\n"); - fprintf(stderr, "Read ROMFILE, writing assets to PATH.\n"); - fprintf(stderr, "With no PATH, assume \"extracted/\".\n"); - return EXIT_FAILURE; - } - - romfile = argv[1]; - - if (argc > 2) { - strcpy(g_OutPath, argv[2]); - } else { - strcpy(g_OutPath, "extracted"); - } - - if (g_OutPath[strlen(g_OutPath) - 1] == '/') { - g_OutPath[strlen(g_OutPath) - 1] = '\0'; - } - - extract_rom(romfile); - - return EXIT_SUCCESS; -} diff --git a/port/pdextract/setups_decl.h b/port/pdextract/setups_decl.h index ab650168b..e78afd62b 100644 --- a/port/pdextract/setups_decl.h +++ b/port/pdextract/setups_decl.h @@ -1,8 +1,6 @@ #ifndef _IN_SETUP_DECL #define _IN_SETUP_DECL - -#include #include "common.h" diff --git a/port/pdextract/gbi.c b/port/pdextract/util_gbi.c similarity index 100% rename from port/pdextract/gbi.c rename to port/pdextract/util_gbi.c diff --git a/port/src/preprocess.c b/port/src/preprocess.c index b0286aa2b..f575117a4 100644 --- a/port/src/preprocess.c +++ b/port/src/preprocess.c @@ -36,8 +36,8 @@ static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } #define PD_SWAP_PTR(x) x = swapPtr((void *)(x)) -#define PD_PTR_BASE(x, b) (void *)((u8 *)b + (u32)x) -#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (u32)x) +#define PD_PTR_BASE(x, b) (void *)((u8 *)b + (uintptr_t)x) +#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (uintptr_t)x) // HACK: to prevent double-swapping stuff, flag swapped offsets in a bitmap @@ -1007,7 +1007,7 @@ static void preprocessIntroScript(s32 *cmd) PD_SWAP_VAL(cmd[0]); } -void preprocessAnimations(u8 *data, u32 size) +u8* preprocessAnimations(u8* data, u32 size, u32* outSize) { // set the anim table pointers as well extern u8 *_animationsTableRomStart; @@ -1032,9 +1032,10 @@ void preprocessAnimations(u8 *data, u32 size) anim->data = 0xffffffff; } } + return 0; } -void preprocessMpConfigs(u8 *data, u32 size) +u8* preprocessMpConfigs(u8* data, u32 size, u32* outSize) { const u32 count = size / sizeof(struct mpconfig); struct mpconfig *cfg = (struct mpconfig *)data; @@ -1064,10 +1065,12 @@ void preprocessMpConfigs(u8 *data, u32 size) #endif } } + return 0; } -void preprocessFont(u8 *data, u32 size) +u8* preprocessFont(u8* data, u32 size, u32* outSize) { + return; struct font *fnt = (struct font *)data; for (s32 i = 0; i < ARRAYCOUNT(fnt->kerning); ++i) { @@ -1092,14 +1095,16 @@ void preprocessFont(u8 *data, u32 size) PD_SWAP_VAL(fnt->chars[i].kerningindex); PD_SWAP_PTR(fnt->chars[i].pixeldata); } + return 0; } -void preprocessJpnFont(u8 *data, u32 size) +u8* preprocessJpnFont(u8* data, u32 size, u32* outSize) { // ??? + return 0; } -void preprocessALBankFile(u8 *data, u32 size) +u8* preprocessALBankFile(u8* data, u32 size, u32* outSize) { memset(swapmap, 0, sizeof(swapmap)); @@ -1111,6 +1116,7 @@ void preprocessALBankFile(u8 *data, u32 size) PD_SWAP_PTR(bankf->bankArray[i]); preprocessALBank(PD_PTR_BASE(bankf->bankArray[i], data), data); } + return 0; } void preprocessALCMidiHdr(u8 *data, u32 size) @@ -1122,7 +1128,7 @@ void preprocessALCMidiHdr(u8 *data, u32 size) } } -void preprocessSequences(u8 *data, u32 size) +u8* preprocessSequences(u8* data, u32 size, u32* outSize) { struct seqtable *seq = (struct seqtable *)data; PD_SWAP_VAL(seq->count); @@ -1132,9 +1138,10 @@ void preprocessSequences(u8 *data, u32 size) PD_SWAP_VAL(seq->entries[i].ziplen); PD_SWAP_VAL(seq->entries[i].romaddr); } + return 0; } -void preprocessTexturesList(u8 *data, u32 size) +u8* preprocessTexturesList(u8* data, u32 size, u32* outSize) { struct texture *tex = (struct texture *)data; const u32 count = size / sizeof(*tex); @@ -1148,6 +1155,7 @@ void preprocessTexturesList(u8 *data, u32 size) tex->soundsurfacetype = tex->surfacetype; tex->surfacetype = tmp; } + return 0; } void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) @@ -1218,15 +1226,16 @@ void preprocessModel(u8 *base, u32 ofs) } } -void preprocessLangFile(u8 *data, u32 size) +u8* preprocessLangFile(u8* data, u32 size, u32* outSize) { // lang banks are just an offset table + text data right after // offsets are from the beginning of the bank // however we cannot byteswap them in advance because the length of the // offset table is unknown, so that's done in lang.c on demand instead + return 0; } -void preprocessPadsFile(u8 *data, u32 size) +u8* preprocessPadsFile(u8* data, u32 size, u32* outSize) { struct padsfileheader *hdr = (void *)data; @@ -1297,9 +1306,10 @@ void preprocessPadsFile(u8 *data, u32 size) ++wg; } } + return 0; } -void preprocessTilesFile(u8 *data, u32 size) +u8* preprocessTilesFile(u8* data, u32 size, u32* outSize) { u32 *roomTable = (u32 *)data; PD_SWAP_VAL(roomTable[0]); @@ -1368,9 +1378,10 @@ void preprocessTilesFile(u8 *data, u32 size) break; } } + return 0; } -void preprocessSetupFile(u8 *data, u32 size) +u8* preprocessSetupFile(u8* data, u32 size, u32* outSize) { struct stagesetup *set = (void *)data; @@ -1422,16 +1433,19 @@ void preprocessSetupFile(u8 *data, u32 size) } // the rest of the pointers are set after loading + return 0; } -void preprocessModelFile(u8 *data, u32 size) +u8* preprocessModelFile(u8* data, u32 size, u32* outSize) { preprocessModel(data, 0x5000000); + return 0; } -void preprocessGunFile(u8 *data, u32 size) +u8* preprocessGunFile(u8* data, u32 size, u32* outSize) { preprocessModel(data, 0x5000000); + return 0; } void preprocessBgSection1Header(u8 *data, u32 size) @@ -1442,6 +1456,7 @@ void preprocessBgSection1Header(u8 *data, u32 size) PD_SWAP_VAL(header[2]); // primcompsize } +#ifndef PLATFORM_64BIT void preprocessBgSection1(u8 *data, u32 ofs) { struct { u32 unk00; @@ -1505,6 +1520,7 @@ void preprocessBgSection1(u8 *data, u32 ofs) { // unused, so won't swap the contents } } +#endif void preprocessBgSection2Header(u8 *data, u32 size) { @@ -1549,6 +1565,7 @@ void preprocessBgSection3(u8 *data, u32 size) } } +#ifndef PLATFORM_64BIT void preprocessBgRoom(u8 *data, u32 ofs) { struct roomgfxdata *rgfx = (void *)data; @@ -1607,6 +1624,7 @@ void preprocessBgRoom(u8 *data, u32 ofs) { } } } +#endif void preprocessBgLights(u8 *data, u32 ofs) { diff --git a/port/src/romdata.c b/port/src/romdata.c index effc67e65..6c3b57973 100644 --- a/port/src/romdata.c +++ b/port/src/romdata.c @@ -4,7 +4,6 @@ #include #include #include -#include #include "lib/rzip.h" #include "romdata.h" #include "fs.h" @@ -99,6 +98,13 @@ static struct romfile fileSlots[ROMDATA_MAX_FILES] = { #define ROMSEG_START(n) _ ## n ## SegmentRomStart #define ROMSEG_END(n) _ ## n ## SegmentRomEnd +// for x64 preprocess functions +#ifdef PLATFORM_64BIT +#define F(preprocessFunc) preprocessFunc##_x64 +#else +#define F(preprocessFunc) preprocessFunc +#endif + /* segment table for ntsc-final */ /* size will get calculated automatically if it is 0 */ /* if there are replacement files in the data dir, they will be loaded instead */ @@ -116,15 +122,15 @@ static struct romfile fileSlots[ROMDATA_MAX_FILES] = { ROMSEG_DECL_SEG(mpstringsS, 0x7e2f20, 0x7ce720, 0x7d25b0, 0x3700, NULL ) \ ROMSEG_DECL_SEG(mpstringsI, 0x7e6620, 0x7d1e20, 0x7d5cb0, 0x3700, NULL ) \ ROMSEG_DECL_SEG(firingrange, 0x7e9d20, 0x7d5520, 0x7d93b0, 0x1550, NULL ) \ - ROMSEG_DECL_SEG(fonttahoma, 0x7f7860, 0x7e3060, 0x7e6ef0, 0x0, preprocessFont ) \ - ROMSEG_DECL_SEG(fontnumeric, 0x7f8b20, 0x7e4320, 0x7e81b0, 0x0, preprocessFont ) \ - ROMSEG_DECL_SEG(fonthandelgothicsm, 0x7f9d30, 0x7e5530, 0x7e93c0, 0x0, preprocessFont ) \ - ROMSEG_DECL_SEG(fonthandelgothicxs, 0x7fbfb0, 0x7e87b0, 0x7ec640, 0x0, preprocessFont ) \ - ROMSEG_DECL_SEG(fonthandelgothicmd, 0x7fdd80, 0x7eae20, 0x7eecb0, 0x0, preprocessFont ) \ - ROMSEG_DECL_SEG(fonthandelgothiclg, 0x8008e0, 0x7eee70, 0x7f2d00, 0x0, preprocessFont ) \ - ROMSEG_DECL_SEG(sfxctl, 0x80a250, 0x7f87e0, 0x7fc670, 0x2fb80, preprocessALBankFile ) \ + ROMSEG_DECL_SEG(fonttahoma, 0x7f7860, 0x7e3060, 0x7e6ef0, 0x0, F(preprocessFont) ) \ + ROMSEG_DECL_SEG(fontnumeric, 0x7f8b20, 0x7e4320, 0x7e81b0, 0x0, F(preprocessFont) ) \ + ROMSEG_DECL_SEG(fonthandelgothicsm, 0x7f9d30, 0x7e5530, 0x7e93c0, 0x0, F(preprocessFont) ) \ + ROMSEG_DECL_SEG(fonthandelgothicxs, 0x7fbfb0, 0x7e87b0, 0x7ec640, 0x0, F(preprocessFont) ) \ + ROMSEG_DECL_SEG(fonthandelgothicmd, 0x7fdd80, 0x7eae20, 0x7eecb0, 0x0, F(preprocessFont) ) \ + ROMSEG_DECL_SEG(fonthandelgothiclg, 0x8008e0, 0x7eee70, 0x7f2d00, 0x0, F(preprocessFont) ) \ + ROMSEG_DECL_SEG(sfxctl, 0x80a250, 0x7f87e0, 0x7fc670, 0x2fb80, F(preprocessALBankFile) ) \ ROMSEG_DECL_SEG(sfxtbl, 0x839dd0, 0x828360, 0x82c1f0, 0x4c2160, NULL ) \ - ROMSEG_DECL_SEG(seqctl, 0xcfbf30, 0xcea4c0, 0xcee350, 0xa060, preprocessALBankFile ) \ + ROMSEG_DECL_SEG(seqctl, 0xcfbf30, 0xcea4c0, 0xcee350, 0xa060, F(preprocessALBankFile) ) \ ROMSEG_DECL_SEG(seqtbl, 0xd05f90, 0xcf4520, 0xcf83b0, 0x17c070, NULL ) \ ROMSEG_DECL_SEG(sequences, 0xe82000, 0xe70590, 0xe74420, 0x563a0, preprocessSequences ) \ ROMSEG_DECL_SEG(texturesdata, 0x1d65f40, 0x1d5ca20, 0x1d61f90, 0x0, NULL ) \ @@ -165,14 +171,16 @@ static struct romfile romSegs[] = { static preprocessfunc filePreprocFuncs[] = { /* LOADTYPE_NONE */ NULL, /* LOADTYPE_BG */ NULL, // loaded in parts - /* LOADTYPE_TILES */ preprocessTilesFile, - /* LOADTYPE_LANG */ preprocessLangFile, - /* LOADTYPE_SETUP */ preprocessSetupFile, - /* LOADTYPE_PADS */ preprocessPadsFile, - /* LOADTYPE_MODEL */ preprocessModelFile, - /* LOADTYPE_GUN */ preprocessGunFile, + /* LOADTYPE_TILES */ F(preprocessTilesFile), + /* LOADTYPE_LANG */ F(preprocessLangFile), + /* LOADTYPE_SETUP */ F(preprocessSetupFile), + /* LOADTYPE_PADS */ F(preprocessPadsFile), + /* LOADTYPE_MODEL */ F(preprocessModelFile), + /* LOADTYPE_GUN */ F(preprocessModelFile), }; +#undef F + static inline void romdataWrongRomError(const char *fmt, ...) { char reason[1024]; @@ -236,6 +244,17 @@ static inline void romdataLoadRom(void) romDataSegSize = dataSegLen; } +static inline void romdataUpdateSegStartEnd(struct romfile* seg) +{ + if (seg->segstart) { + *seg->segstart = seg->data; + } + + if (seg->segend) { + *seg->segend = seg->data + seg->size; + } +} + static inline void romdataInitSegment(struct romfile *seg) { if (!seg->data) { @@ -269,7 +288,7 @@ static inline void romdataInitSegment(struct romfile *seg) if (g_RomFile) { newData = g_RomFile + (uintptr_t)seg->data; seg->source = SRC_ROM; - sysLogPrintf(LOG_NOTE, "loading segment %s from ROM (offset %08x pointer %p)", seg->name, (u32)seg->data, newData); + sysLogPrintf(LOG_NOTE, "loading segment %s from ROM (offset %08x pointer %p)", seg->name, (uintptr_t)seg->data, newData); } else { sysFatalError("No ROM or external file for segment:\n%s", seg->name); } @@ -281,17 +300,19 @@ static inline void romdataInitSegment(struct romfile *seg) seg->data = newData; - if (seg->segstart) { - *seg->segstart = seg->data; - } - - if (seg->segend) { - *seg->segend = seg->data + seg->size; - } + romdataUpdateSegStartEnd(seg); // call the post load function if any if (seg->preprocess && !seg->preprocessed) { - seg->preprocess(seg->data, seg->size); + newData = seg->preprocess(seg->data, seg->size, &seg->size); + + if (newData) { + if (seg->source == SRC_EXTERNAL) + sysMemFree(seg->data); + seg->data = newData; + romdataUpdateSegStartEnd(seg); + } + seg->preprocessed = 1; } } @@ -447,7 +468,7 @@ u8 *romdataFileLoad(s32 fileNum, u32 *outSize) return out; } -void romdataFilePreprocess(s32 fileNum, s32 loadType, u8 *data, u32 size) +void romdataFilePreprocess(s32 fileNum, s32 loadType, u8 *data, u32 size, u32 *outSize) { if (fileNum < 1 || fileNum >= ROMDATA_MAX_FILES) { sysLogPrintf(LOG_ERROR, "romdataFilePreprocess: invalid file num %d", fileNum); @@ -465,7 +486,7 @@ void romdataFilePreprocess(s32 fileNum, s32 loadType, u8 *data, u32 size) } } // then preprocess - filePreprocFuncs[loadType](data, size); + filePreprocFuncs[loadType](data, size, outSize); // fileSlots[fileNum].preprocessed = 1; } } diff --git a/src/game/file.c b/src/game/file.c index 815e7612e..dce879590 100644 --- a/src/game/file.c +++ b/src/game/file.c @@ -4209,7 +4209,7 @@ void fileLoad(u8 *dst, u32 allocationlen, romptr_t *romaddrptr, struct fileinfo #ifndef PLATFORM_N64 // byteswap/preprocess file according to g_LoadType right after inflating it const u32 dstsize = allocationlen ? info->loadedsize : romsize; - romdataFilePreprocess(filenum, g_LoadType, dst, dstsize); + romdataFilePreprocess(filenum, g_LoadType, dst, dstsize, &info->loadedsize); g_LoadType = LOADTYPE_NONE; #endif } diff --git a/src/include/constants.h b/src/include/constants.h index 9a7c25e5f..ac33bf32c 100644 --- a/src/include/constants.h +++ b/src/include/constants.h @@ -48,7 +48,9 @@ #define ABS(val) ((val) > 0 ? (val) : -(val)) #define ABSF(val) ((val) > 0.0f ? (val) : -(val)) +#define ALIGN(val, size) ((val + (size - 1)) & ~(size - 1)) #define ALIGN2(val) (((val) | 1) ^ 0x1) +#define ALIGN4(val) (((val) | 3) ^ 0x3) #define ALIGN8(val) ((((val) + 0x7) | 0x7) ^ 0x7) #define ALIGN16(val) ((((val) + 0xf) | 0xf) ^ 0xf) #define ALIGN64(val) (((((uintptr_t)(val)) + 0x3f) | 0x3f) ^ 0x3f) From 167a4a5d81c2457aee709858da01e0ddb0ece118 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 16:48:35 +0800 Subject: [PATCH 14/81] portx64: pd-extract: replaced stdint types with ultratypes --- port/pdextract/ext_audio.c | 196 ++++++++++---------- port/pdextract/ext_file_bg.c | 208 ++++++++++----------- port/pdextract/ext_file_lang.c | 28 +-- port/pdextract/ext_file_model.c | 316 ++++++++++++++++---------------- port/pdextract/ext_file_pads.c | 104 +++++------ port/pdextract/ext_file_tiles.c | 52 +++--- port/pdextract/ext_fonts.c | 60 +++--- 7 files changed, 482 insertions(+), 482 deletions(-) diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c index dbf8e27c5..f3dbc3f8a 100644 --- a/port/pdextract/ext_audio.c +++ b/port/pdextract/ext_audio.c @@ -9,44 +9,44 @@ enum { }; struct generic_adpcm_book { - int32_t order; - int32_t npredictors; - int16_t book[128]; + s32 order; + s32 npredictors; + s16 book[128]; }; struct generic_adpcm_loop { - uint32_t start; - uint32_t end; - uint32_t count; - int16_t state[16]; + u32 start; + u32 end; + u32 count; + s16 state[16]; }; struct generic_raw_loop { - uint32_t start; - uint32_t end; - uint32_t count; + u32 start; + u32 end; + u32 count; }; struct generic_envelope { - int32_t attackTime; - int32_t decayTime; - int32_t releaseTime; - uint8_t attackVolume; - uint8_t decayVolume; + s32 attackTime; + s32 decayTime; + s32 releaseTime; + u8 attackVolume; + u8 decayVolume; }; struct generic_keymap { - uint8_t velocityMin; - uint8_t velocityMax; - uint8_t keyMin; - uint8_t keyMax; - uint8_t keyBase; - int8_t detune; + u8 velocityMin; + u8 velocityMax; + u8 keyMin; + u8 keyMax; + u8 keyBase; + s8 detune; }; struct n64_adpcm_waveinfo { - uint32_t loop; // ptr to struct generic_adpcm_loop - uint32_t book; // ptr to struct generic_adpcm_book + u32 loop; // ptr to struct generic_adpcm_loop + u32 book; // ptr to struct generic_adpcm_book }; struct host_adpcm_waveinfo { @@ -55,7 +55,7 @@ struct host_adpcm_waveinfo { }; struct n64_raw_waveinfo { - uint32_t loop; // ptr to struct generic_raw_loop + u32 loop; // ptr to struct generic_raw_loop }; struct host_raw_waveinfo { @@ -63,10 +63,10 @@ struct host_raw_waveinfo { }; struct n64_wavetable { - uint32_t base; - int32_t len; - uint8_t type; - uint8_t flags; + u32 base; + s32 len; + u8 type; + u8 flags; union { struct n64_adpcm_waveinfo adpcmWave; struct n64_raw_waveinfo rawWave; @@ -75,9 +75,9 @@ struct n64_wavetable { struct host_wavetable { uintptr_t base; - int32_t len; - uint8_t type; - uint8_t flags; + s32 len; + u8 type; + u8 flags; union { struct host_adpcm_waveinfo adpcmWave; struct host_raw_waveinfo rawWave; @@ -85,90 +85,90 @@ struct host_wavetable { }; struct n64_sound { - uint32_t envelope; // ptr to struct generic_envelope - uint32_t keyMap; // ptr to struct generic_keymap - uint32_t wavetable; // ptr to struct n64_wavetable - uint8_t samplePan; - uint8_t sampleVolume; - uint8_t flags; + u32 envelope; // ptr to struct generic_envelope + u32 keyMap; // ptr to struct generic_keymap + u32 wavetable; // ptr to struct n64_wavetable + u8 samplePan; + u8 sampleVolume; + u8 flags; }; struct host_sound { uintptr_t envelope; // ptr to struct generic_envelope uintptr_t keyMap; // ptr to struct generic_keymap uintptr_t wavetable; // ptr to struct host_wavetable - uint8_t samplePan; - uint8_t sampleVolume; - uint8_t flags; + u8 samplePan; + u8 sampleVolume; + u8 flags; }; struct n64_instrument { - uint8_t volume; - uint8_t pan; - uint8_t priority; - uint8_t flags; - uint8_t tremType; - uint8_t tremRate; - uint8_t tremDepth; - uint8_t tremDelay; - uint8_t vibType; - uint8_t vibRate; - uint8_t vibDepth; - uint8_t vibDelay; - int16_t bendRange; - int16_t soundCount; - uint32_t soundArray[1]; // ptr to struct n64_sound + u8 volume; + u8 pan; + u8 priority; + u8 flags; + u8 tremType; + u8 tremRate; + u8 tremDepth; + u8 tremDelay; + u8 vibType; + u8 vibRate; + u8 vibDepth; + u8 vibDelay; + s16 bendRange; + s16 soundCount; + u32 soundArray[1]; // ptr to struct n64_sound }; struct host_instrument { - uint8_t volume; - uint8_t pan; - uint8_t priority; - uint8_t flags; - uint8_t tremType; - uint8_t tremRate; - uint8_t tremDepth; - uint8_t tremDelay; - uint8_t vibType; - uint8_t vibRate; - uint8_t vibDepth; - uint8_t vibDelay; - int16_t bendRange; - int16_t soundCount; + u8 volume; + u8 pan; + u8 priority; + u8 flags; + u8 tremType; + u8 tremRate; + u8 tremDepth; + u8 tremDelay; + u8 vibType; + u8 vibRate; + u8 vibDepth; + u8 vibDelay; + s16 bendRange; + s16 soundCount; uintptr_t soundArray[1]; // ptr to struct host_sound }; struct n64_bank { - int16_t instCount; - uint8_t flags; - uint8_t pad; - int32_t sampleRate; - uint32_t percussion; // ptr to struct n64_instrument - uint32_t instArray[1]; // ptr to struct n64_instrument + s16 instCount; + u8 flags; + u8 pad; + s32 sampleRate; + u32 percussion; // ptr to struct n64_instrument + u32 instArray[1]; // ptr to struct n64_instrument }; struct host_bank { - int16_t instCount; - uint8_t flags; - uint8_t pad; - int32_t sampleRate; + s16 instCount; + u8 flags; + u8 pad; + s32 sampleRate; uintptr_t percussion; // ptr to struct host_instrument uintptr_t instArray[1]; // ptr to struct host_instrument }; struct n64_bankfile { - int16_t revision; - int16_t bankCount; - uint32_t bankArray[1]; // ptr to struct n64_bank + s16 revision; + s16 bankCount; + u32 bankArray[1]; // ptr to struct n64_bank }; struct host_bankfile { - int16_t revision; - int16_t bankCount; + s16 revision; + s16 bankCount; uintptr_t bankArray[1]; // ptr to struct host_bank }; -static int convert_audio_envelope(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_envelope(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_envelope *n64_envelope = (struct generic_envelope *) &src[srcpos]; struct generic_envelope *host_envelope = (struct generic_envelope *) &dst[dstpos]; @@ -184,7 +184,7 @@ static int convert_audio_envelope(uint8_t *dst, int dstpos, uint8_t *src, int sr return dstpos; } -static int convert_audio_keymap(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_keymap(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_keymap *n64_keymap = (struct generic_keymap *) &src[srcpos]; struct generic_keymap *host_keymap = (struct generic_keymap *) &dst[dstpos]; @@ -201,7 +201,7 @@ static int convert_audio_keymap(uint8_t *dst, int dstpos, uint8_t *src, int srcp return dstpos; } -static int convert_audio_adpcm_loop(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_adpcm_loop(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_adpcm_loop *n64_loop = (struct generic_adpcm_loop *) &src[srcpos]; struct generic_adpcm_loop *host_loop = (struct generic_adpcm_loop *) &dst[dstpos]; @@ -219,7 +219,7 @@ static int convert_audio_adpcm_loop(uint8_t *dst, int dstpos, uint8_t *src, int return dstpos; } -static int convert_audio_adpcm_book(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_adpcm_book(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_adpcm_book *n64_book = (struct generic_adpcm_book *) &src[srcpos]; struct generic_adpcm_book *host_book = (struct generic_adpcm_book *) &dst[dstpos]; @@ -236,7 +236,7 @@ static int convert_audio_adpcm_book(uint8_t *dst, int dstpos, uint8_t *src, int return dstpos; } -static int convert_audio_raw_loop(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_raw_loop(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_raw_loop *n64_loop = (struct generic_raw_loop *) &src[srcpos]; struct generic_raw_loop *host_loop = (struct generic_raw_loop *) &dst[dstpos]; @@ -250,7 +250,7 @@ static int convert_audio_raw_loop(uint8_t *dst, int dstpos, uint8_t *src, int sr return dstpos; } -static int convert_audio_wavetable(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_wavetable(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_wavetable *n64_wavetable = (struct n64_wavetable *) &src[srcpos]; struct host_wavetable *host_wavetable = (struct host_wavetable *) &dst[dstpos]; @@ -291,7 +291,7 @@ static int convert_audio_wavetable(uint8_t *dst, int dstpos, uint8_t *src, int s return dstpos; } -static int convert_audio_sound(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_sound(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_sound *n64_sound = (struct n64_sound *) &src[srcpos]; struct host_sound *host_sound = (struct host_sound *) &dst[dstpos]; @@ -329,7 +329,7 @@ static int convert_audio_sound(uint8_t *dst, int dstpos, uint8_t *src, int srcpo return dstpos; } -static int convert_audio_instrument(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_instrument(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_instrument *n64_instrument = (struct n64_instrument *) &src[srcpos]; struct host_instrument *host_instrument = (struct host_instrument *) &dst[dstpos]; @@ -361,7 +361,7 @@ static int convert_audio_instrument(uint8_t *dst, int dstpos, uint8_t *src, int return dstpos; } -static int convert_audio_bank(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_bank(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_bank *n64_bank = (struct n64_bank *) &src[srcpos]; struct host_bank *host_bank = (struct host_bank *) &dst[dstpos]; @@ -391,7 +391,7 @@ static int convert_audio_bank(uint8_t *dst, int dstpos, uint8_t *src, int srcpos return dstpos; } -static int convert_audio_bankfile(uint8_t *dst, uint8_t *src) +static int convert_audio_bankfile(u8 *dst, u8 *src) { struct n64_bankfile *n64_bankfile = (struct n64_bankfile *)src; struct host_bankfile *host_bankfile = (struct host_bankfile *)dst; @@ -401,21 +401,21 @@ static int convert_audio_bankfile(uint8_t *dst, uint8_t *src) host_bankfile->bankCount = htodst16(bankCount); - uint32_t dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); + u32 dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); for (int i = 0; i < bankCount; i++) { host_bankfile->bankArray[i] = htodst32(dstpos); - uint32_t srcpos = srctoh32(n64_bankfile->bankArray[i]); + u32 srcpos = srctoh32(n64_bankfile->bankArray[i]); dstpos = convert_audio_bank(dst, dstpos, src, srcpos); } return dstpos; } -uint8_t *preprocessALBankFile_x64(uint8_t *src, uint32_t size, uint32_t *outSize) +u8 *preprocessALBankFile_x64(u8 *src, u32 size, u32 *outSize) { size_t dstlen = size * 4; - uint8_t *dst = calloc(1, dstlen); + u8 *dst = calloc(1, dstlen); *outSize = convert_audio_bankfile(dst, src); *outSize = ALIGN16(*outSize); diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c index d756678d0..69a445356 100644 --- a/port/pdextract/ext_file_bg.c +++ b/port/pdextract/ext_file_bg.c @@ -7,7 +7,7 @@ #include "platform.h" struct ptrmarker { - uint32_t ptr_src; + u32 ptr_src; uintptr_t ptr_host; }; @@ -16,7 +16,7 @@ struct ptrmarker m_PtrMarkers[2048]; int m_NumPtrMarkers; int m_SizeGDLs; -static void add_marker(uint32_t ptr_src, uintptr_t ptr_host) +static void add_marker(u32 ptr_src, uintptr_t ptr_host) { if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { sysLogPrintf(LOG_ERROR, "[BG] Marker limit exceeded"); @@ -77,23 +77,23 @@ static void reset_markers() */ struct fileheader { - uint32_t primary_infsize; - uint32_t section1_cmpsize; - uint32_t primary_cmpsize; + u32 primary_infsize; + u32 section1_cmpsize; + u32 primary_cmpsize; }; struct sectionheader { - uint16_t infsize; - uint16_t cmpsize; + u16 infsize; + u16 cmpsize; }; struct n64_primaryheader { - uint32_t unused1; - uint32_t ptr_rooms; - uint32_t ptr_portals; - uint32_t ptr_bgcmds; - uint32_t ptr_lights; - uint32_t unused2; + u32 unused1; + u32 ptr_rooms; + u32 ptr_portals; + u32 ptr_bgcmds; + u32 ptr_lights; + u32 unused2; }; struct host_primaryheader { @@ -106,63 +106,63 @@ struct host_primaryheader { }; struct n64_room { - uint32_t ptr_gfxdata; - uint32_t pos[3]; - uint8_t br_light_min; - uint8_t br_light_max; + u32 ptr_gfxdata; + u32 pos[3]; + u8 br_light_min; + u8 br_light_max; }; struct host_room { uintptr_t ptr_gfxdata; - uint32_t pos[3]; - uint8_t br_light_min; - uint8_t br_light_max; + u32 pos[3]; + u8 br_light_min; + u8 br_light_max; }; struct portal { - uint16_t verticesoffset; - int16_t roomnum1; - int16_t roomnum2; - uint8_t flags; + u16 verticesoffset; + s16 roomnum1; + s16 roomnum2; + u8 flags; }; struct portalvertices { - uint8_t count; - uint32_t vertices[1][3]; + u8 count; + u32 vertices[1][3]; }; struct bgcmd { - uint8_t type; - uint8_t len; - int32_t param; + u8 type; + u8 len; + s32 param; }; struct light { - uint16_t roomnum; - uint16_t colour; - uint8_t brightness; - uint8_t sparkable : 1; - uint8_t healthy : 1; - uint8_t on : 1; - uint8_t sparking : 1; - uint8_t vulnerable : 1; - uint8_t brightnessmult; - int8_t dirx; - int8_t diry; - int8_t dirz; - int16_t bbox[4][3]; + u16 roomnum; + u16 colour; + u8 brightness; + u8 sparkable : 1; + u8 healthy : 1; + u8 on : 1; + u8 sparking : 1; + u8 vulnerable : 1; + u8 brightnessmult; + s8 dirx; + s8 diry; + s8 dirz; + s16 bbox[4][3]; }; struct n64_roomblock { - uint8_t type; - uint32_t ptr_next; - uint32_t ptr_gdl; - uint32_t ptr_vertices; - uint32_t ptr_colours; + u8 type; + u32 ptr_next; + u32 ptr_gdl; + u32 ptr_vertices; + u32 ptr_colours; }; struct host_roomblock { - uint8_t type; + u8 type; uintptr_t ptr_next; uintptr_t ptr_gdl; uintptr_t ptr_vertices; @@ -170,14 +170,14 @@ struct host_roomblock { }; struct n64_roomgfxdata { - uint32_t ptr_vertices; - uint32_t ptr_colours; - uint32_t ptr_opablocks; - uint32_t ptr_xlublocks; - int16_t lightsindex; - int16_t numlights; - int16_t numvertices; - int16_t numcolours; + u32 ptr_vertices; + u32 ptr_colours; + u32 ptr_opablocks; + u32 ptr_xlublocks; + s16 lightsindex; + s16 numlights; + s16 numvertices; + s16 numcolours; // roomblocks[] }; @@ -186,26 +186,26 @@ struct host_roomgfxdata { uintptr_t ptr_colours; uintptr_t ptr_opablocks; uintptr_t ptr_xlublocks; - int16_t lightsindex; - int16_t numlights; - int16_t numvertices; - int16_t numcolours; + s16 lightsindex; + s16 numlights; + s16 numvertices; + s16 numcolours; // roomblocks[] }; struct vtx { - int16_t coord[3]; - uint8_t flag; - uint8_t color; - uint16_t s; - uint16_t t; + s16 coord[3]; + u8 flag; + u8 color; + u16 s; + u16 t; }; int m_NumRooms; -uint32_t m_AllocSizes[512]; +u32 m_AllocSizes[512]; -static void convert_primary_rooms(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_primary_rooms(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { struct n64_room *n64_rooms = (struct n64_room *) &src[*srcpos]; struct host_room *host_rooms = (struct host_room *) &dst[*dstpos]; @@ -229,7 +229,7 @@ static void convert_primary_rooms(uint8_t *dst, uint32_t *dstpos, uint8_t *src, *dstpos += sizeof(*host_rooms) * (m_NumRooms +2); } -static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t *src_portalvtxs, uint32_t *dst_portalvtxs) +static void convert_primary_portals(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 *src_portalvtxs, u32 *dst_portalvtxs) { struct portal *n64_portals = (struct portal *) &src[*srcpos]; struct portal *host_portals = (struct portal *) &dst[*dstpos]; @@ -274,7 +274,7 @@ static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src } } -static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t dst_portalvtxs, uint32_t src_portalvtxs) +static void convert_primary_bgcmds(u8 *dst, u32 *dstpos, u8 *src, u32 dst_portalvtxs, u32 src_portalvtxs) { struct bgcmd *n64_cmds = (struct bgcmd *) src; struct bgcmd *host_cmds = (struct bgcmd *) &dst[*dstpos]; @@ -292,7 +292,7 @@ static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, host_cmds[i].param = srctodst32(n64_cmds[i].param); if (host_cmds[i].type == 0x64) { - uint32_t offset = host_cmds[i].param - src_portalvtxs; + u32 offset = host_cmds[i].param - src_portalvtxs; host_cmds[i].param = dst_portalvtxs + offset; } } @@ -300,7 +300,7 @@ static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, *dstpos += sizeof(*host_cmds) * num_cmds; } -static void convert_primary_lights(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t end) +static void convert_primary_lights(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 end) { struct light *n64_lights = (struct light *) &src[*srcpos]; struct light *host_lights = (struct light *) &dst[*dstpos]; @@ -347,11 +347,11 @@ void relink_ptr(uintptr_t** ptr) *ptr = marker->ptr_host; } -static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_t infsize, uint32_t src_ofs) +static u32 convert_section1_roomgfxdata(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) { reset_markers(); - uint32_t dst_roomoffset = src_ofs; + u32 dst_roomoffset = src_ofs; uintptr_t gdls_addr[64]; int numgdls = 0; @@ -407,8 +407,8 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_ // block coords for (size_t i = 0; i < ncoords; i++) { - uint32_t *src_coord = (uint32_t*)(src + curpos_src); - uint32_t *dst_coord = (uint32_t*)(dst + curpos_dst); + u32 *src_coord = (u32*)(src + curpos_src); + u32 *dst_coord = (u32*)(dst + curpos_dst); dst_coord[0] = srctoh32(src_coord[0]); dst_coord[1] = srctoh32(src_coord[1]); @@ -420,8 +420,8 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_ add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - curpos_src += 6 * sizeof(uint32_t); - curpos_dst += 6 * sizeof(uint32_t); + curpos_src += 6 * sizeof(u32); + curpos_dst += 6 * sizeof(u32); } curpos_dst = ALIGN8(curpos_dst); @@ -492,8 +492,8 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_ if (block->type == BLOCK_LEAF) { relink_ptr(&block->ptr_gdl); - uint32_t offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; - uint32_t offset_col = block->ptr_colours - ptr_src_colors - src_ofs; + u32 offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; + u32 offset_col = block->ptr_colours - ptr_src_colors - src_ofs; block->ptr_vertices = ptr_dst_vertices + offset_vtx; block->ptr_colours = ptr_dst_colors + offset_col; @@ -513,17 +513,17 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_ return curpos_dst; } -static uint32_t convert_section1(uint8_t *dst, uint8_t *src, uint32_t ofs) +static u32 convert_section1(u8 *dst, u8 *src, u32 ofs) { // Convert primary - uint32_t srcpos = 0; - uint32_t dstpos = 0; + u32 srcpos = 0; + u32 dstpos = 0; struct host_primaryheader *host_primary_header = (struct host_primaryheader *) dst; struct n64_primaryheader *n64_primary_header = (struct n64_primaryheader *) src; srcpos += sizeof(struct n64_primaryheader); dstpos += sizeof(*host_primary_header); - uint32_t src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - ofs; + u32 src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - ofs; host_primary_header->unused1 = 0; host_primary_header->unused2 = 0; @@ -539,7 +539,7 @@ static uint32_t convert_section1(uint8_t *dst, uint8_t *src, uint32_t ofs) host_primary_header->ptr_portals = dstpos + ofs; srcpos = srctodst32(n64_primary_header->ptr_portals) - ofs; - uint32_t src_portalvtxs, dst_portalvtxs; + u32 src_portalvtxs, dst_portalvtxs; convert_primary_portals(dst, &dstpos, src, &srcpos, &src_portalvtxs, &dst_portalvtxs); host_primary_header->ptr_bgcmds = dstpos + ofs; @@ -548,11 +548,11 @@ static uint32_t convert_section1(uint8_t *dst, uint8_t *src, uint32_t ofs) return dstpos; } -static void convert_section2_texturenums(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t srclen) +static void convert_section2_texturenums(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 srclen) { - uint16_t *src_ids = (uint16_t *) &src[*srcpos]; - uint16_t *dst_ids = (uint16_t *) &dst[*dstpos]; - int count = srclen / sizeof(uint16_t); + u16 *src_ids = (u16 *) &src[*srcpos]; + u16 *dst_ids = (u16 *) &dst[*dstpos]; + int count = srclen / sizeof(u16); for (int i = 0; i < count; i++) { dst_ids[i] = srctodst16(src_ids[i]); @@ -562,10 +562,10 @@ static void convert_section2_texturenums(uint8_t *dst, uint32_t *dstpos, uint8_t *dstpos += srclen; } -static void convert_section3_bboxes(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_section3_bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { - int16_t *src_bboxes = (int16_t *) &src[*srcpos]; - int16_t *dst_bboxes = (int16_t *) &dst[*dstpos]; + s16 *src_bboxes = (s16 *) &src[*srcpos]; + s16 *dst_bboxes = (s16 *) &dst[*dstpos]; for (int i = 0; i < m_NumRooms; i++) { dst_bboxes[i * 6 + 0] = srctodst16(src_bboxes[i * 6 + 0]); @@ -576,23 +576,23 @@ static void convert_section3_bboxes(uint8_t *dst, uint32_t *dstpos, uint8_t *src dst_bboxes[i * 6 + 5] = srctodst16(src_bboxes[i * 6 + 5]); } - *srcpos += sizeof(int16_t) * 6 * (m_NumRooms - 1); - *dstpos += sizeof(int16_t) * 6 * (m_NumRooms - 1); + *srcpos += sizeof(s16) * 6 * (m_NumRooms - 1); + *dstpos += sizeof(s16) * 6 * (m_NumRooms - 1); } -static void convert_section3_allocsizes(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_section3_allocsizes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { - uint16_t *dst_sizes = (uint16_t *) &dst[*dstpos]; + u16 *dst_sizes = (u16 *) &dst[*dstpos]; for (int i = 0; i < m_NumRooms; i++) { dst_sizes[i] = (m_AllocSizes[i] - 0x100) / 0x10; } - *srcpos += sizeof(uint16_t) * (m_NumRooms - 1); - *dstpos += sizeof(uint16_t) * (m_NumRooms - 1); + *srcpos += sizeof(u16) * (m_NumRooms - 1); + *dstpos += sizeof(u16) * (m_NumRooms - 1); } -static void convert_section3_lightcounts(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_section3_lightcounts(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { memcpy(&dst[*dstpos], &src[*srcpos], m_NumRooms); @@ -601,11 +601,11 @@ static void convert_section3_lightcounts(uint8_t *dst, uint32_t *dstpos, uint8_t } #ifdef PLATFORM_64BIT -void preprocessBgSection1(uint8_t *data, uint32_t size, uint32_t ofs) +void preprocessBgSection1(u8 *data, u32 size, u32 ofs) { - uint8_t *dst = sysMemZeroAlloc(size); + u8 *dst = sysMemZeroAlloc(size); - uint32_t newSize = convert_section1(dst, data, ofs); + u32 newSize = convert_section1(dst, data, ofs); if (newSize > size) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg file, size %d newsize %d", size, newSize); @@ -616,11 +616,11 @@ void preprocessBgSection1(uint8_t *data, uint32_t size, uint32_t ofs) sysMemFree(dst); } -uint32_t preprocessBgRoom(uint8_t *data, uint32_t size, uint32_t room_ofs) +u32 preprocessBgRoom(u8 *data, u32 size, u32 room_ofs) { size *= 2; - uint8_t *dst = sysMemZeroAlloc(size); - uint32_t newSize = convert_section1_roomgfxdata(dst, data, size, room_ofs); + u8 *dst = sysMemZeroAlloc(size); + u32 newSize = convert_section1_roomgfxdata(dst, data, size, room_ofs); if (newSize > size) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg room, size %d newsize %d", size, newSize); diff --git a/port/pdextract/ext_file_lang.c b/port/pdextract/ext_file_lang.c index 9764c3a24..d0dc74e7e 100644 --- a/port/pdextract/ext_file_lang.c +++ b/port/pdextract/ext_file_lang.c @@ -4,10 +4,10 @@ #include "common.h" #include "system.h" -static int get_next_nonzero(uint8_t *src, uint32_t offset, size_t len) +static int get_next_nonzero(u8 *src, u32 offset, size_t len) { - uint32_t *ptr = (uint32_t *) &src[offset]; - uint32_t *end = (uint32_t *) &src[len]; + u32 *ptr = (u32 *) &src[offset]; + u32 *end = (u32 *) &src[len]; while (ptr < end) { if (*ptr != 0) { @@ -20,21 +20,21 @@ static int get_next_nonzero(uint8_t *src, uint32_t offset, size_t len) return 0; } -static int get_num_strings(uint8_t *src, size_t len) +static int get_num_strings(u8 *src, size_t len) { - uint32_t ptr_table_len = get_next_nonzero(src, 0, len); + u32 ptr_table_len = get_next_nonzero(src, 0, len); if (ptr_table_len) { - return ptr_table_len / sizeof(uint32_t); + return ptr_table_len / sizeof(u32); } return 1; } -uint32_t convert_lang_file(uint8_t *dst, uint8_t *src, size_t srclen) +u32 convert_lang_file(u8 *dst, u8 *src, size_t srclen) { // Convert it - uint32_t *src_offsets = (uint32_t *) src; + u32 *src_offsets = (u32 *) src; size_t src_ptr_table_len = srctoh32(src_offsets[0]); size_t src_str_table_len = srclen - src_ptr_table_len; int num_strings = get_num_strings(src, srclen); @@ -46,14 +46,14 @@ uint32_t convert_lang_file(uint8_t *dst, uint8_t *src, size_t srclen) uintptr_t *dst_offsets = (uintptr_t *) dst; for (int i = 0; i < num_strings; i++) { - uint32_t src_offset = srctoh32(src_offsets[i]); + u32 src_offset = srctoh32(src_offsets[i]); if (src_offset) { // Write pointer dst_offsets[i] = htodst32(cur_dst_offset); // Write string - uint32_t end = get_next_nonzero(src, (i + 1) * 4, num_strings * 4); + u32 end = get_next_nonzero(src, (i + 1) * 4, num_strings * 4); if (!end) { end = srclen; @@ -73,11 +73,11 @@ uint32_t convert_lang_file(uint8_t *dst, uint8_t *src, size_t srclen) return ALIGN16(cur_dst_offset); } -uint8_t *preprocessLangFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) { - uint32_t newSizeEstimated = (uint32_t)(size * 1.3); - uint8_t *dst = sysMemZeroAlloc(newSizeEstimated); +u8 *preprocessLangFile_x64(u8 *data, u32 size, u32 *outSize) { + u32 newSizeEstimated = (u32)(size * 1.3); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); - uint32_t newSize = convert_lang_file(dst, data, size); + u32 newSize = convert_lang_file(dst, data, size); if (newSize > newSizeEstimated) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a lang file, size %d newsize %d", size, newSize); diff --git a/port/pdextract/ext_file_model.c b/port/pdextract/ext_file_model.c index aa8e29321..3ce24b05d 100644 --- a/port/pdextract/ext_file_model.c +++ b/port/pdextract/ext_file_model.c @@ -29,9 +29,9 @@ enum contenttype { }; struct marker { - uint32_t src_offset; - uint32_t dst_offset; - uint32_t parent_src_offset; + u32 src_offset; + u32 dst_offset; + u32 parent_src_offset; enum contenttype type; }; @@ -90,40 +90,40 @@ int m_NumMarkers; #define MODELNODETYPE_0200 0x0200 struct src_modeldef { - uint32_t ptr_rootnode; - uint32_t ptr_skel; - uint32_t ptr_parts; - int16_t numparts; - int16_t nummatrices; - uint32_t scale; - uint16_t rwdatalen; - uint16_t numtexconfigs; - uint32_t ptr_texconfigs; + u32 ptr_rootnode; + u32 ptr_skel; + u32 ptr_parts; + s16 numparts; + s16 nummatrices; + u32 scale; + u16 rwdatalen; + u16 numtexconfigs; + u32 ptr_texconfigs; }; struct dst_modeldef { uintptr_t ptr_rootnode; uintptr_t ptr_skel; uintptr_t ptr_parts; - int16_t numparts; - int16_t nummatrices; - uint32_t scale; - uint16_t rwdatalen; - uint16_t numtexconfigs; + s16 numparts; + s16 nummatrices; + u32 scale; + u16 rwdatalen; + u16 numtexconfigs; uintptr_t ptr_texconfigs; }; struct src_modelnode { - uint16_t type; - uint32_t ptr_rodata; - uint32_t ptr_parent; - uint32_t ptr_next; - uint32_t ptr_prev; - uint32_t ptr_child; + u16 type; + u32 ptr_rodata; + u32 ptr_parent; + u32 ptr_next; + u32 ptr_prev; + u32 ptr_child; }; struct dst_modelnode { - uint16_t type; + u16 type; uintptr_t ptr_rodata; uintptr_t ptr_parent; uintptr_t ptr_next; @@ -132,26 +132,26 @@ struct dst_modelnode { }; struct generic_rodata_chrinfo { - uint16_t animpart; - int16_t mtxindex; - uint32_t unk04; - uint16_t rwdataindex; + u16 animpart; + s16 mtxindex; + u32 unk04; + u16 rwdataindex; }; struct generic_rodata_position { - uint32_t pos[3]; - uint16_t part; - int16_t mtxindexes[3]; - uint32_t drawdist; + u32 pos[3]; + u16 part; + s16 mtxindexes[3]; + u32 drawdist; }; struct src_rodata_gundl { - uint32_t ptr_opagdl; - uint32_t ptr_xlugdl; - uint32_t ptr_baseaddr; - uint32_t ptr_vertices; - int16_t numvertices; - int16_t unk12; + u32 ptr_opagdl; + u32 ptr_xlugdl; + u32 ptr_baseaddr; + u32 ptr_vertices; + s16 numvertices; + s16 unk12; }; struct dst_rodata_gundl { @@ -159,130 +159,130 @@ struct dst_rodata_gundl { uintptr_t ptr_xlugdl; uintptr_t ptr_baseaddr; uintptr_t ptr_vertices; - int16_t numvertices; - int16_t unk12; + s16 numvertices; + s16 unk12; }; struct src_rodata_distance { - uint32_t near; - uint32_t far; - uint32_t ptr_target; - uint16_t rwdataindex; + u32 near; + u32 far; + u32 ptr_target; + u16 rwdataindex; }; struct dst_rodata_distance { - uint32_t near; - uint32_t far; + u32 near; + u32 far; uintptr_t ptr_target; - uint16_t rwdataindex; + u16 rwdataindex; }; struct src_rodata_reorder { - uint32_t unk00; - uint32_t unk04; - uint32_t unk08; - uint32_t unk0c[3]; - uint32_t ptr_node_unk18; - uint32_t ptr_node_unk1c; - int16_t side; - uint16_t rwdataindex; + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c[3]; + u32 ptr_node_unk18; + u32 ptr_node_unk1c; + s16 side; + u16 rwdataindex; }; struct dst_rodata_reorder { - uint32_t unk00; - uint32_t unk04; - uint32_t unk08; - uint32_t unk0c[3]; + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c[3]; uintptr_t ptr_node_unk18; uintptr_t ptr_node_unk1c; - int16_t side; - uint16_t rwdataindex; + s16 side; + u16 rwdataindex; }; struct generic_rodata_bbox { - int32_t hitpart; - uint32_t bbox[6]; + s32 hitpart; + u32 bbox[6]; }; struct src_rodata_chrgunfire { - uint32_t pos[3]; - uint32_t dim[3]; - uint32_t ptr_texture; - uint32_t unk1c; - uint16_t rwdataindex; - uint32_t ptr_baseaddr; + u32 pos[3]; + u32 dim[3]; + u32 ptr_texture; + u32 unk1c; + u16 rwdataindex; + u32 ptr_baseaddr; }; struct dst_rodata_chrgunfire { - uint32_t pos[3]; - uint32_t dim[3]; + u32 pos[3]; + u32 dim[3]; uintptr_t ptr_texture; - uint32_t unk1c; - uint16_t rwdataindex; + u32 unk1c; + u16 rwdataindex; uintptr_t ptr_baseaddr; }; struct src_rodata_type11 { - uint32_t unk00; - uint32_t unk04; - uint32_t unk08; - uint32_t unk0c; - uint32_t unk10; - uint32_t ptr_unk14; + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c; + u32 unk10; + u32 ptr_unk14; }; struct dst_rodata_type11 { - uint32_t unk00; - uint32_t unk04; - uint32_t unk08; - uint32_t unk0c; - uint32_t unk10; + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c; + u32 unk10; uintptr_t ptr_unk14; }; struct src_rodata_toggle { - uint32_t ptr_target; - uint16_t rwdataindex; + u32 ptr_target; + u16 rwdataindex; }; struct dst_rodata_toggle { uintptr_t ptr_target; - uint16_t rwdataindex; + u16 rwdataindex; }; struct generic_rodata_positionheld { - uint32_t pos[3]; - int16_t mtxindex; - uint32_t unk10; + u32 pos[3]; + s16 mtxindex; + u32 unk10; }; struct src_rodata_stargunfire { - uint32_t unk00; - uint32_t ptr_vertices; - uint32_t ptr_gdl; - uint32_t ptr_baseaddr; + u32 unk00; + u32 ptr_vertices; + u32 ptr_gdl; + u32 ptr_baseaddr; }; struct dst_rodata_stargunfire { - uint32_t unk00; + u32 unk00; uintptr_t ptr_vertices; uintptr_t ptr_gdl; uintptr_t ptr_baseaddr; }; struct generic_rodata_headspot { - uint16_t rwdataindex; + u16 rwdataindex; }; struct src_rodata_dl { - uint32_t ptr_opagdl; - uint32_t ptr_xlugdl; - uint32_t ptr_colours; - uint32_t ptr_vertices; // colours follow this array - int16_t numvertices; - int16_t mcount; - uint16_t rwdataindex; - uint16_t numcolours; + u32 ptr_opagdl; + u32 ptr_xlugdl; + u32 ptr_colours; + u32 ptr_vertices; // colours follow this array + s16 numvertices; + s16 mcount; + u16 rwdataindex; + u16 numcolours; }; struct dst_rodata_dl { @@ -290,42 +290,42 @@ struct dst_rodata_dl { uintptr_t ptr_xlugdl; uintptr_t ptr_colours; uintptr_t ptr_vertices; // colours follow this array - int16_t numvertices; - int16_t mcount; - uint16_t rwdataindex; - uint16_t numcolours; + s16 numvertices; + s16 mcount; + u16 rwdataindex; + u16 numcolours; }; struct generic_rodata_type19 { - uint32_t numvertices; - uint32_t vertices[3]; + u32 numvertices; + u32 vertices[3]; }; struct src_texconfig { - uint32_t ptr; - uint8_t width; - uint8_t height; - uint8_t level; - uint8_t format; - uint8_t depth; - uint8_t s; - uint8_t t; - uint8_t unk0b; + u32 ptr; + u8 width; + u8 height; + u8 level; + u8 format; + u8 depth; + u8 s; + u8 t; + u8 unk0b; }; struct dst_texconfig { uintptr_t ptr; - uint8_t width; - uint8_t height; - uint8_t level; - uint8_t format; - uint8_t depth; - uint8_t s; - uint8_t t; - uint8_t unk0b; + u8 width; + u8 height; + u8 level; + u8 format; + u8 depth; + u8 s; + u8 t; + u8 unk0b; }; -static struct marker *find_marker(uint32_t src_offset) +static struct marker *find_marker(u32 src_offset) { for (int i = 0; i < m_NumMarkers; i++) { if (m_Markers[i].src_offset == src_offset) { @@ -336,7 +336,7 @@ static struct marker *find_marker(uint32_t src_offset) return NULL; } -static void set_marker(uint32_t src_offset, enum contenttype type, uint32_t parent_src_offset) +static void set_marker(u32 src_offset, enum contenttype type, u32 parent_src_offset) { if (src_offset == 0) { return; @@ -388,7 +388,7 @@ enum contenttype m_NodeTypeToContentType[] = { /*0x19*/ CT_RODATA_19, }; -static void populate_markers(uint8_t *src) +static void populate_markers(u8 *src) { m_NumMarkers = 0; @@ -398,13 +398,13 @@ static void populate_markers(uint8_t *src) struct marker *marker = &m_Markers[i]; void *src_thing = &src[marker->src_offset]; int numvtx = 0; - uint32_t colstart = 0; + u32 colstart = 0; switch (marker->type) { case CT_MODELDEF: struct src_modeldef *src_modeldef = src_thing; int num_texconfigs = srctoh16(src_modeldef->numtexconfigs); - uint32_t texconfigpos = srctoh32(src_modeldef->ptr_texconfigs); + u32 texconfigpos = srctoh32(src_modeldef->ptr_texconfigs); set_marker(srctoh32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); set_marker(srctoh32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); @@ -414,7 +414,7 @@ static void populate_markers(uint8_t *src) break; case CT_NODE: struct src_modelnode *src_node = src_thing; - uint32_t node_type = srctoh16(src_node->type) & 0xff; + u32 node_type = srctoh16(src_node->type) & 0xff; set_marker(srctoh32(src_node->ptr_rodata), m_NodeTypeToContentType[node_type], marker->src_offset); set_marker(srctoh32(src_node->ptr_parent), CT_NODE, marker->src_offset); set_marker(srctoh32(src_node->ptr_next), CT_NODE, marker->src_offset); @@ -429,7 +429,7 @@ static void populate_markers(uint8_t *src) break; case CT_PARTS: struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - uint32_t *src_parts = (uint32_t *) src_thing; + u32 *src_parts = (u32 *) src_thing; int num_parts = srctoh16(src_modeldef2->numparts); for (int i = 0; i < num_parts; i++) { @@ -503,7 +503,7 @@ static void populate_markers(uint8_t *src) static void sort_markers(void) { for (int i = 0; i < m_NumMarkers - 1; i++) { - uint32_t min_offset = 0xffffffff; + u32 min_offset = 0xffffffff; int min_index = -1; for (int j = i + 1; j < m_NumMarkers; j++) { @@ -521,15 +521,15 @@ static void sort_markers(void) } } -static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_len) +static u32 convert_content(u8 *dst, u8 *src, u32 src_file_len) { - uint32_t dstpos = 0; + u32 dstpos = 0; for (int i = 0; i < m_NumMarkers; i++) { struct marker *marker = &m_Markers[i]; void *src_thing = &src[marker->src_offset]; - uint32_t src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; - uint32_t src_len = src_end - marker->src_offset; + u32 src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; + u32 src_len = src_end - marker->src_offset; dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].before); @@ -584,16 +584,16 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le break; case CT_PARTS: struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - uint32_t *src_parts = (uint32_t *) src_thing; + u32 *src_parts = (u32 *) src_thing; uintptr_t *dst_parts = (uintptr_t *) dst_thing; int num_parts = srctoh16(src_modeldef2->numparts); - uint16_t *src_nums = (uint16_t *) &src_parts[num_parts]; - uint16_t *dst_nums = (uint16_t *) &dst_parts[num_parts]; + u16 *src_nums = (u16 *) &src_parts[num_parts]; + u16 *dst_nums = (u16 *) &dst_parts[num_parts]; for (int i = 0; i < num_parts; i++) { dst_nums[i] = srctodst16(src_nums[i]); } - dstpos += num_parts * sizeof(uintptr_t) + num_parts * sizeof(uint16_t); + dstpos += num_parts * sizeof(uintptr_t) + num_parts * sizeof(u16); if (num_parts) { dstpos = ALIGN8(dstpos); } @@ -604,8 +604,8 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le break; case CT_GDL: struct marker *parent = find_marker(marker->parent_src_offset); - uint32_t src_vtx; - uint32_t dst_vtx; + u32 src_vtx; + u32 dst_vtx; if (parent->type == CT_RODATA_GUNDL) { struct src_rodata_gundl *src_rodata = (struct src_rodata_gundl *) &src[parent->src_offset]; @@ -754,18 +754,18 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le case CT_RODATA_19: struct generic_rodata_type19 *src_type19 = src_thing; struct generic_rodata_type19 *dst_type19 = dst_thing; - uint32_t *src_vertices = src_thing + sizeof(uint32_t); - uint32_t *dst_vertices = dst_thing + sizeof(uint32_t); + u32 *src_vertices = src_thing + sizeof(u32); + u32 *dst_vertices = dst_thing + sizeof(u32); int num_vertices = srctoh32(src_type19->numvertices); dst_type19->numvertices = htodst32(num_vertices); - dstpos += sizeof(uint32_t); + dstpos += sizeof(u32); for (int i = 0; i < num_vertices; i++) { dst_vertices[i * 3 + 0] = srctodst32(src_vertices[i * 3 + 0]); dst_vertices[i * 3 + 1] = srctodst32(src_vertices[i * 3 + 1]); dst_vertices[i * 3 + 2] = srctodst32(src_vertices[i * 3 + 2]); - dstpos += sizeof(uint32_t) * 3; + dstpos += sizeof(u32) * 3; } break; } @@ -776,7 +776,7 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le return dstpos; } -static uint32_t resolve_pointer(uint32_t src_offset) +static u32 resolve_pointer(u32 src_offset) { if (src_offset == 0) { return 0; @@ -786,7 +786,7 @@ static uint32_t resolve_pointer(uint32_t src_offset) return marker ? (0x05000000 | marker->dst_offset) : 0; } -static void relink_pointers(uint8_t *dst, uint8_t *src) +static void relink_pointers(u8 *dst, u8 *src) { for (int i = 0; i < m_NumMarkers; i++) { struct marker *marker = &m_Markers[i]; @@ -820,7 +820,7 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) break; case CT_PARTS: struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - uint32_t *src_parts = (uint32_t *) src_thing; + u32 *src_parts = (u32 *) src_thing; uintptr_t *dst_parts = (uintptr_t *) dst_thing; int num_parts = srctoh16(src_modeldef2->numparts); @@ -918,9 +918,9 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) } } -static int convert_model(uint8_t *dst, uint8_t *src, uint32_t srclen) +static int convert_model(u8 *dst, u8 *src, u32 srclen) { - uint32_t dstpos; + u32 dstpos; populate_markers(src); sort_markers(); @@ -931,14 +931,14 @@ static int convert_model(uint8_t *dst, uint8_t *src, uint32_t srclen) return dstpos; } -uint8_t *preprocessModelFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) +u8 *preprocessModelFile_x64(u8 *data, u32 size, u32 *outSize) { gbi_reset(); - uint32_t newSizeEstimated = (uint32_t)(size * 1.7); - uint8_t *dst = sysMemZeroAlloc(newSizeEstimated); + u32 newSizeEstimated = (u32)(size * 1.7); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); - uint32_t newSize = convert_model(dst, data, size); + u32 newSize = convert_model(dst, data, size); if (newSize > newSizeEstimated) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); diff --git a/port/pdextract/ext_file_pads.c b/port/pdextract/ext_file_pads.c index 46bfa7187..bba3b6b2b 100644 --- a/port/pdextract/ext_file_pads.c +++ b/port/pdextract/ext_file_pads.c @@ -16,66 +16,66 @@ #define PADFLAG_HASBBOXDATA 0x0200 struct n64_header { - int32_t num_pads; - int32_t num_covers; - uint32_t ptr_waypoints; - uint32_t ptr_waygroups; - uint32_t ptr_cover; + s32 num_pads; + s32 num_covers; + u32 ptr_waypoints; + u32 ptr_waygroups; + u32 ptr_cover; }; struct host_header { - int32_t num_pads; - int32_t num_covers; + s32 num_pads; + s32 num_covers; uintptr_t ptr_waypoints; uintptr_t ptr_waygroups; uintptr_t ptr_cover; }; struct padheader { - uint32_t flags : 18; - uint32_t room : 10; - uint32_t liftnum : 4; + u32 flags : 18; + u32 room : 10; + u32 liftnum : 4; }; struct n64_waypoint { - int32_t padnum; - uint32_t ptr_neighbours; - int32_t groupnum; - int32_t step; + s32 padnum; + u32 ptr_neighbours; + s32 groupnum; + s32 step; }; struct host_waypoint { - int32_t padnum; + s32 padnum; uintptr_t ptr_neighbours; - int32_t groupnum; - int32_t step; + s32 groupnum; + s32 step; }; struct n64_waygroup { - uint32_t ptr_neighbours; - uint32_t ptr_waypoints; - int32_t step; + u32 ptr_neighbours; + u32 ptr_waypoints; + s32 step; }; struct host_waygroup { uintptr_t ptr_neighbours; uintptr_t ptr_waypoints; - int32_t step; + s32 step; }; struct coverdefinition { - uint32_t pos[3]; - uint32_t dir[3]; - uint16_t flags; - uint16_t unk1a; + u32 pos[3]; + u32 dir[3]; + u16 flags; + u16 unk1a; }; -static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int num_pads) +static int convert_pads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) { - uint16_t *src_offsets = (uint16_t *) &src[srcpos]; - uint16_t *dst_offsets = (uint16_t *) &dst[dstpos]; + u16 *src_offsets = (u16 *) &src[srcpos]; + u16 *dst_offsets = (u16 *) &dst[dstpos]; - dstpos += num_pads * sizeof(uint16_t); + dstpos += num_pads * sizeof(u16); for (int i = 0; i < num_pads; i++) { dstpos = ALIGN4(dstpos); @@ -84,19 +84,19 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int dst_offsets[i] = htodst16(dstpos); // Header - uint32_t n64_padheader = srctoh32(*(uint32_t *) &src[srcpos]); + u32 n64_padheader = srctoh32(*(u32 *) &src[srcpos]); struct padheader *host_padheader = (struct padheader *) &dst[dstpos]; - uint32_t flags = (n64_padheader >> 14) & 0x3ffff; + u32 flags = (n64_padheader >> 14) & 0x3ffff; - *(uint32_t*)host_padheader = htodst32(n64_padheader); + *(u32*)host_padheader = htodst32(n64_padheader); srcpos += sizeof(struct padheader); dstpos += sizeof(struct padheader); // Position if (flags & PADFLAG_INTPOS) { - int16_t *srcptr = (int16_t *) &src[srcpos]; - int16_t *dstptr = (int16_t *) &dst[dstpos]; + s16 *srcptr = (s16 *) &src[srcpos]; + s16 *dstptr = (s16 *) &dst[dstpos]; dstptr[0] = srctodst16(srcptr[0]); dstptr[1] = srctodst16(srcptr[1]); @@ -105,8 +105,8 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int srcpos += 8; dstpos += 8; } else { - uint32_t *srcptr = (uint32_t *) &src[srcpos]; - uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; dstptr[0] = srctodst32(srcptr[0]); dstptr[1] = srctodst32(srcptr[1]); @@ -118,8 +118,8 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int // Up if ((flags & (PADFLAG_UPALIGNTOX | PADFLAG_UPALIGNTOY | PADFLAG_UPALIGNTOZ)) == 0) { - uint32_t *srcptr = (uint32_t *) &src[srcpos]; - uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; dstptr[0] = srctodst32(srcptr[0]); dstptr[1] = srctodst32(srcptr[1]); @@ -131,8 +131,8 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int // Look if ((flags & (PADFLAG_LOOKALIGNTOX | PADFLAG_LOOKALIGNTOY | PADFLAG_LOOKALIGNTOZ)) == 0) { - uint32_t *srcptr = (uint32_t *) &src[srcpos]; - uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; dstptr[0] = srctodst32(srcptr[0]); dstptr[1] = srctodst32(srcptr[1]); @@ -144,8 +144,8 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int // Bbox if (flags & PADFLAG_HASBBOXDATA) { - uint32_t *srcptr = (uint32_t *) &src[srcpos]; - uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; dstptr[0] = srctodst32(srcptr[0]); dstptr[1] = srctodst32(srcptr[1]); @@ -162,7 +162,7 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int return dstpos; } -static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_waypoints(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_waypoint *n64_waypoints = (struct n64_waypoint *) &src[srcpos]; struct host_waypoint *host_waypoints = (struct host_waypoint *) &dst[dstpos]; @@ -172,7 +172,7 @@ static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) dstpos += (num_waypoints + 1) * sizeof(struct host_waypoint); - uint32_t *host_neighbours = (uint32_t *) &dst[dstpos]; + u32 *host_neighbours = (u32 *) &dst[dstpos]; int n = 0; for (int i = 0; i < num_waypoints; i++) { @@ -181,7 +181,7 @@ static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) host_waypoints[i].groupnum = srctodst32(n64_waypoints[i].groupnum); host_waypoints[i].step = 0; - uint32_t *n64_neighbours = (uint32_t *) &src[srctoh32(n64_waypoints[i].ptr_neighbours)]; + u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waypoints[i].ptr_neighbours)]; for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { host_neighbours[n++] = srctodst32(n64_neighbours[j]); @@ -201,7 +201,7 @@ static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) return dstpos; } -static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_waygroups(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_waygroup *n64_waygroups = (struct n64_waygroup *) &src[srcpos]; struct host_waygroup *host_waygroups = (struct host_waygroup *) &dst[dstpos]; @@ -212,14 +212,14 @@ static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) dstpos += (num_waygroups + 1) * sizeof(struct host_waygroup); // Waygroups and child waypoints - uint32_t *host_waypoints = (uint32_t *) &dst[dstpos]; + u32 *host_waypoints = (u32 *) &dst[dstpos]; int n = 0; for (int i = 0; i < num_waygroups; i++) { host_waygroups[i].ptr_waypoints = htodst32(dstpos); host_waygroups[i].step = 0; - uint32_t *n64_waypoints = (uint32_t *) &src[srctoh32(n64_waygroups[i].ptr_waypoints)]; + u32 *n64_waypoints = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_waypoints)]; for (int j = 0; n64_waypoints[j] != 0xffffffff; j++) { host_waypoints[n++] = srctodst32(n64_waypoints[j]); @@ -236,13 +236,13 @@ static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) host_waygroups[num_waygroups].step = 0; // Waygroup neighbours - uint32_t *host_neighbours = (uint32_t *) &dst[dstpos]; + u32 *host_neighbours = (u32 *) &dst[dstpos]; n = 0; for (int i = 0; i < num_waygroups; i++) { host_waygroups[i].ptr_neighbours = htodst32(dstpos); - uint32_t *n64_neighbours = (uint32_t *) &src[srctoh32(n64_waygroups[i].ptr_neighbours)]; + u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_neighbours)]; for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { host_neighbours[n++] = srctodst32(n64_neighbours[j]); @@ -256,7 +256,7 @@ static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) return dstpos; } -static int convert_cover(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int num_covers) +static int convert_cover(u8 *dst, int dstpos, u8 *src, int srcpos, int num_covers) { struct coverdefinition *n64_covers = (struct coverdefinition *) &src[srcpos]; struct coverdefinition *host_covers = (struct coverdefinition *) &dst[dstpos]; @@ -277,7 +277,7 @@ static int convert_cover(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int return dstpos; } -static int convert_pads_file(uint8_t *dst, uint8_t *src) +static int convert_pads_file(u8 *dst, u8 *src) { int dstpos = 0; struct n64_header *n64_header = (struct n64_header *) src; diff --git a/port/pdextract/ext_file_tiles.c b/port/pdextract/ext_file_tiles.c index 4c2bf6b76..e5ca85454 100644 --- a/port/pdextract/ext_file_tiles.c +++ b/port/pdextract/ext_file_tiles.c @@ -6,37 +6,37 @@ struct tile { - uint8_t type; - uint8_t numvertices; - uint16_t flags; - uint16_t floortype; - uint8_t xmin; - uint8_t ymin; - uint8_t zmin; - uint8_t xmax; - uint8_t ymax; - uint8_t zmax; - uint16_t floorcol; + u8 type; + u8 numvertices; + u16 flags; + u16 floortype; + u8 xmin; + u8 ymin; + u8 zmin; + u8 xmax; + u8 ymax; + u8 zmax; + u16 floorcol; }; -uint32_t convert_tiles(uint8_t *dst, uint8_t *src, size_t srclen) +u32 convert_tiles(u8 *dst, u8 *src, size_t srclen) { - int num_rooms = srctoh32(*(uint32_t *) src); + int num_rooms = srctoh32(*(u32 *) src); size_t src_ptr_table_len = (num_rooms + 1) * 4; - size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(uint32_t); + size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(u32); - uint32_t *src_offsets = (uint32_t *) &src[4]; + u32 *src_offsets = (u32 *) &src[4]; size_t data_len = srclen - src_ptr_table_len - 4; - *(uint32_t *) dst = htodst32(num_rooms); + *(u32 *) dst = htodst32(num_rooms); - uint32_t *dst_offsets = (uint32_t *) (dst + sizeof(uint32_t)); - uint32_t cur_dst_offset = dst_ptr_table_len + sizeof(uint32_t); + u32 *dst_offsets = (u32 *) (dst + sizeof(u32)); + u32 cur_dst_offset = dst_ptr_table_len + sizeof(u32); - uint32_t cur_src_offset = srctoh32(src_offsets[0]); - uint32_t end_src_offset = srctoh32(src_offsets[num_rooms]); + u32 cur_src_offset = srctoh32(src_offsets[0]); + u32 end_src_offset = srctoh32(src_offsets[num_rooms]); int room = 0; while (1) { @@ -73,9 +73,9 @@ uint32_t convert_tiles(uint8_t *dst, uint8_t *src, size_t srclen) // Write tile vertices for (int i = 0; i < hosttile.numvertices; i++) { - *(int16_t *) &dst[cur_dst_offset + 0] = srctodst16(*(int16_t *) &src[cur_src_offset + 0]); - *(int16_t *) &dst[cur_dst_offset + 2] = srctodst16(*(int16_t *) &src[cur_src_offset + 2]); - *(int16_t *) &dst[cur_dst_offset + 4] = srctodst16(*(int16_t *) &src[cur_src_offset + 4]); + *(s16 *) &dst[cur_dst_offset + 0] = srctodst16(*(s16 *) &src[cur_src_offset + 0]); + *(s16 *) &dst[cur_dst_offset + 2] = srctodst16(*(s16 *) &src[cur_src_offset + 2]); + *(s16 *) &dst[cur_dst_offset + 4] = srctodst16(*(s16 *) &src[cur_src_offset + 4]); cur_dst_offset += 6; cur_src_offset += 6; } @@ -84,11 +84,11 @@ uint32_t convert_tiles(uint8_t *dst, uint8_t *src, size_t srclen) return ALIGN16(cur_dst_offset); } -uint8_t *preprocessTilesFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) +u8 *preprocessTilesFile_x64(u8 *data, u32 size, u32 *outSize) { - uint8_t *dst = sysMemZeroAlloc(size); + u8 *dst = sysMemZeroAlloc(size); - uint32_t newSize = convert_tiles(dst, data, size); + u32 newSize = convert_tiles(dst, data, size); if (newSize > size) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a tiles file, size %d newsize %d", size, newSize); diff --git a/port/pdextract/ext_fonts.c b/port/pdextract/ext_fonts.c index eddddedff..6d8c49bdf 100644 --- a/port/pdextract/ext_fonts.c +++ b/port/pdextract/ext_fonts.c @@ -7,44 +7,44 @@ #include "system.h" struct n64fontchar { - uint8_t index; - int8_t baseline; - uint8_t height; - uint8_t width; - int32_t kerningindex; - uint32_t pixeldata; + u8 index; + s8 baseline; + u8 height; + u8 width; + s32 kerningindex; + u32 pixeldata; }; struct hostfontchar { - uint8_t index; - int8_t baseline; - uint8_t height; - uint8_t width; - int32_t kerningindex; + u8 index; + s8 baseline; + u8 height; + u8 width; + s32 kerningindex; uintptr_t pixeldata; }; struct n64fontcharjpn { - uint16_t index; - int8_t baseline; - uint8_t height; - uint8_t width; - int16_t kerningindex; - uint32_t pixeldata; + u16 index; + s8 baseline; + u8 height; + u8 width; + s16 kerningindex; + u32 pixeldata; }; struct hostfontcharjpn { - uint16_t index; - int8_t baseline; - uint8_t height; - uint8_t width; - int16_t kerningindex; + u16 index; + s8 baseline; + u8 height; + u8 width; + s16 kerningindex; uintptr_t pixeldata; }; struct fontdef { const char *name; - uint32_t offsets[3]; + u32 offsets[3]; int pal_extra_chars; }; @@ -64,24 +64,24 @@ u8* preprocessFont_x64(u8 *src, u32 srclen, u32 *outSize) #endif size_t dstlen = srclen - (num_chars * sizeof(struct n64fontchar)) + (num_chars * sizeof(struct hostfontchar)) + 0x20; - uint8_t* dst = sysMemZeroAlloc(dstlen); + u8* dst = sysMemZeroAlloc(dstlen); // Kerning table - int32_t *src_kerning_table = (int32_t *)src; - int32_t *dst_kerning_table = (int32_t *)dst; + s32 *src_kerning_table = (s32 *)src; + s32 *dst_kerning_table = (s32 *)dst; for (int i = 0; i < 13 * 13; i++) { dst_kerning_table[i] = srctodst32(src_kerning_table[i]); } - uint32_t src_offset = ALIGN(13 * 13 * 4, sizeof(uint32_t)); - uint32_t dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); + u32 src_offset = ALIGN(13 * 13 * 4, sizeof(u32)); + u32 dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); // Character table #if VERSION == VERSION_JPN_FINAL struct n64fontcharjpn *src_char_table = (struct n64fontcharjpn *) &src[src_offset]; struct hostfontcharjpn *dst_char_table = (struct hostfontcharjpn *) &dst[dst_offset]; - uint32_t diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); + u32 diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); for (int i = 0; i < num_chars; i++) { dst_char_table[i].index = srctodst16(src_char_table[i].index); @@ -97,7 +97,7 @@ u8* preprocessFont_x64(u8 *src, u32 srclen, u32 *outSize) #else struct n64fontchar *src_char_table = (struct n64fontchar *) &src[src_offset]; struct hostfontchar *dst_char_table = (struct hostfontchar *) &dst[dst_offset]; - uint32_t diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); + u32 diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); for (int i = 0; i < num_chars; i++) { dst_char_table[i].index = src_char_table[i].index; From 58c31075b0dfde7b59f5830634f0b9b0649dc66b Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 16:48:35 +0800 Subject: [PATCH 15/81] portx64: pd-extract: replaced stdint types with ultratypes --- port/pdextract/ext_audio.c | 196 ++++++++++---------- port/pdextract/ext_file_bg.c | 208 ++++++++++----------- port/pdextract/ext_file_lang.c | 28 +-- port/pdextract/ext_file_model.c | 316 ++++++++++++++++---------------- port/pdextract/ext_file_pads.c | 104 +++++------ port/pdextract/ext_file_tiles.c | 52 +++--- port/pdextract/ext_fonts.c | 60 +++--- port/pdextract/util_gbi.c | 46 ++--- 8 files changed, 505 insertions(+), 505 deletions(-) diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c index dbf8e27c5..f3dbc3f8a 100644 --- a/port/pdextract/ext_audio.c +++ b/port/pdextract/ext_audio.c @@ -9,44 +9,44 @@ enum { }; struct generic_adpcm_book { - int32_t order; - int32_t npredictors; - int16_t book[128]; + s32 order; + s32 npredictors; + s16 book[128]; }; struct generic_adpcm_loop { - uint32_t start; - uint32_t end; - uint32_t count; - int16_t state[16]; + u32 start; + u32 end; + u32 count; + s16 state[16]; }; struct generic_raw_loop { - uint32_t start; - uint32_t end; - uint32_t count; + u32 start; + u32 end; + u32 count; }; struct generic_envelope { - int32_t attackTime; - int32_t decayTime; - int32_t releaseTime; - uint8_t attackVolume; - uint8_t decayVolume; + s32 attackTime; + s32 decayTime; + s32 releaseTime; + u8 attackVolume; + u8 decayVolume; }; struct generic_keymap { - uint8_t velocityMin; - uint8_t velocityMax; - uint8_t keyMin; - uint8_t keyMax; - uint8_t keyBase; - int8_t detune; + u8 velocityMin; + u8 velocityMax; + u8 keyMin; + u8 keyMax; + u8 keyBase; + s8 detune; }; struct n64_adpcm_waveinfo { - uint32_t loop; // ptr to struct generic_adpcm_loop - uint32_t book; // ptr to struct generic_adpcm_book + u32 loop; // ptr to struct generic_adpcm_loop + u32 book; // ptr to struct generic_adpcm_book }; struct host_adpcm_waveinfo { @@ -55,7 +55,7 @@ struct host_adpcm_waveinfo { }; struct n64_raw_waveinfo { - uint32_t loop; // ptr to struct generic_raw_loop + u32 loop; // ptr to struct generic_raw_loop }; struct host_raw_waveinfo { @@ -63,10 +63,10 @@ struct host_raw_waveinfo { }; struct n64_wavetable { - uint32_t base; - int32_t len; - uint8_t type; - uint8_t flags; + u32 base; + s32 len; + u8 type; + u8 flags; union { struct n64_adpcm_waveinfo adpcmWave; struct n64_raw_waveinfo rawWave; @@ -75,9 +75,9 @@ struct n64_wavetable { struct host_wavetable { uintptr_t base; - int32_t len; - uint8_t type; - uint8_t flags; + s32 len; + u8 type; + u8 flags; union { struct host_adpcm_waveinfo adpcmWave; struct host_raw_waveinfo rawWave; @@ -85,90 +85,90 @@ struct host_wavetable { }; struct n64_sound { - uint32_t envelope; // ptr to struct generic_envelope - uint32_t keyMap; // ptr to struct generic_keymap - uint32_t wavetable; // ptr to struct n64_wavetable - uint8_t samplePan; - uint8_t sampleVolume; - uint8_t flags; + u32 envelope; // ptr to struct generic_envelope + u32 keyMap; // ptr to struct generic_keymap + u32 wavetable; // ptr to struct n64_wavetable + u8 samplePan; + u8 sampleVolume; + u8 flags; }; struct host_sound { uintptr_t envelope; // ptr to struct generic_envelope uintptr_t keyMap; // ptr to struct generic_keymap uintptr_t wavetable; // ptr to struct host_wavetable - uint8_t samplePan; - uint8_t sampleVolume; - uint8_t flags; + u8 samplePan; + u8 sampleVolume; + u8 flags; }; struct n64_instrument { - uint8_t volume; - uint8_t pan; - uint8_t priority; - uint8_t flags; - uint8_t tremType; - uint8_t tremRate; - uint8_t tremDepth; - uint8_t tremDelay; - uint8_t vibType; - uint8_t vibRate; - uint8_t vibDepth; - uint8_t vibDelay; - int16_t bendRange; - int16_t soundCount; - uint32_t soundArray[1]; // ptr to struct n64_sound + u8 volume; + u8 pan; + u8 priority; + u8 flags; + u8 tremType; + u8 tremRate; + u8 tremDepth; + u8 tremDelay; + u8 vibType; + u8 vibRate; + u8 vibDepth; + u8 vibDelay; + s16 bendRange; + s16 soundCount; + u32 soundArray[1]; // ptr to struct n64_sound }; struct host_instrument { - uint8_t volume; - uint8_t pan; - uint8_t priority; - uint8_t flags; - uint8_t tremType; - uint8_t tremRate; - uint8_t tremDepth; - uint8_t tremDelay; - uint8_t vibType; - uint8_t vibRate; - uint8_t vibDepth; - uint8_t vibDelay; - int16_t bendRange; - int16_t soundCount; + u8 volume; + u8 pan; + u8 priority; + u8 flags; + u8 tremType; + u8 tremRate; + u8 tremDepth; + u8 tremDelay; + u8 vibType; + u8 vibRate; + u8 vibDepth; + u8 vibDelay; + s16 bendRange; + s16 soundCount; uintptr_t soundArray[1]; // ptr to struct host_sound }; struct n64_bank { - int16_t instCount; - uint8_t flags; - uint8_t pad; - int32_t sampleRate; - uint32_t percussion; // ptr to struct n64_instrument - uint32_t instArray[1]; // ptr to struct n64_instrument + s16 instCount; + u8 flags; + u8 pad; + s32 sampleRate; + u32 percussion; // ptr to struct n64_instrument + u32 instArray[1]; // ptr to struct n64_instrument }; struct host_bank { - int16_t instCount; - uint8_t flags; - uint8_t pad; - int32_t sampleRate; + s16 instCount; + u8 flags; + u8 pad; + s32 sampleRate; uintptr_t percussion; // ptr to struct host_instrument uintptr_t instArray[1]; // ptr to struct host_instrument }; struct n64_bankfile { - int16_t revision; - int16_t bankCount; - uint32_t bankArray[1]; // ptr to struct n64_bank + s16 revision; + s16 bankCount; + u32 bankArray[1]; // ptr to struct n64_bank }; struct host_bankfile { - int16_t revision; - int16_t bankCount; + s16 revision; + s16 bankCount; uintptr_t bankArray[1]; // ptr to struct host_bank }; -static int convert_audio_envelope(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_envelope(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_envelope *n64_envelope = (struct generic_envelope *) &src[srcpos]; struct generic_envelope *host_envelope = (struct generic_envelope *) &dst[dstpos]; @@ -184,7 +184,7 @@ static int convert_audio_envelope(uint8_t *dst, int dstpos, uint8_t *src, int sr return dstpos; } -static int convert_audio_keymap(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_keymap(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_keymap *n64_keymap = (struct generic_keymap *) &src[srcpos]; struct generic_keymap *host_keymap = (struct generic_keymap *) &dst[dstpos]; @@ -201,7 +201,7 @@ static int convert_audio_keymap(uint8_t *dst, int dstpos, uint8_t *src, int srcp return dstpos; } -static int convert_audio_adpcm_loop(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_adpcm_loop(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_adpcm_loop *n64_loop = (struct generic_adpcm_loop *) &src[srcpos]; struct generic_adpcm_loop *host_loop = (struct generic_adpcm_loop *) &dst[dstpos]; @@ -219,7 +219,7 @@ static int convert_audio_adpcm_loop(uint8_t *dst, int dstpos, uint8_t *src, int return dstpos; } -static int convert_audio_adpcm_book(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_adpcm_book(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_adpcm_book *n64_book = (struct generic_adpcm_book *) &src[srcpos]; struct generic_adpcm_book *host_book = (struct generic_adpcm_book *) &dst[dstpos]; @@ -236,7 +236,7 @@ static int convert_audio_adpcm_book(uint8_t *dst, int dstpos, uint8_t *src, int return dstpos; } -static int convert_audio_raw_loop(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_raw_loop(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_raw_loop *n64_loop = (struct generic_raw_loop *) &src[srcpos]; struct generic_raw_loop *host_loop = (struct generic_raw_loop *) &dst[dstpos]; @@ -250,7 +250,7 @@ static int convert_audio_raw_loop(uint8_t *dst, int dstpos, uint8_t *src, int sr return dstpos; } -static int convert_audio_wavetable(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_wavetable(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_wavetable *n64_wavetable = (struct n64_wavetable *) &src[srcpos]; struct host_wavetable *host_wavetable = (struct host_wavetable *) &dst[dstpos]; @@ -291,7 +291,7 @@ static int convert_audio_wavetable(uint8_t *dst, int dstpos, uint8_t *src, int s return dstpos; } -static int convert_audio_sound(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_sound(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_sound *n64_sound = (struct n64_sound *) &src[srcpos]; struct host_sound *host_sound = (struct host_sound *) &dst[dstpos]; @@ -329,7 +329,7 @@ static int convert_audio_sound(uint8_t *dst, int dstpos, uint8_t *src, int srcpo return dstpos; } -static int convert_audio_instrument(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_instrument(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_instrument *n64_instrument = (struct n64_instrument *) &src[srcpos]; struct host_instrument *host_instrument = (struct host_instrument *) &dst[dstpos]; @@ -361,7 +361,7 @@ static int convert_audio_instrument(uint8_t *dst, int dstpos, uint8_t *src, int return dstpos; } -static int convert_audio_bank(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_audio_bank(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_bank *n64_bank = (struct n64_bank *) &src[srcpos]; struct host_bank *host_bank = (struct host_bank *) &dst[dstpos]; @@ -391,7 +391,7 @@ static int convert_audio_bank(uint8_t *dst, int dstpos, uint8_t *src, int srcpos return dstpos; } -static int convert_audio_bankfile(uint8_t *dst, uint8_t *src) +static int convert_audio_bankfile(u8 *dst, u8 *src) { struct n64_bankfile *n64_bankfile = (struct n64_bankfile *)src; struct host_bankfile *host_bankfile = (struct host_bankfile *)dst; @@ -401,21 +401,21 @@ static int convert_audio_bankfile(uint8_t *dst, uint8_t *src) host_bankfile->bankCount = htodst16(bankCount); - uint32_t dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); + u32 dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); for (int i = 0; i < bankCount; i++) { host_bankfile->bankArray[i] = htodst32(dstpos); - uint32_t srcpos = srctoh32(n64_bankfile->bankArray[i]); + u32 srcpos = srctoh32(n64_bankfile->bankArray[i]); dstpos = convert_audio_bank(dst, dstpos, src, srcpos); } return dstpos; } -uint8_t *preprocessALBankFile_x64(uint8_t *src, uint32_t size, uint32_t *outSize) +u8 *preprocessALBankFile_x64(u8 *src, u32 size, u32 *outSize) { size_t dstlen = size * 4; - uint8_t *dst = calloc(1, dstlen); + u8 *dst = calloc(1, dstlen); *outSize = convert_audio_bankfile(dst, src); *outSize = ALIGN16(*outSize); diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c index d756678d0..69a445356 100644 --- a/port/pdextract/ext_file_bg.c +++ b/port/pdextract/ext_file_bg.c @@ -7,7 +7,7 @@ #include "platform.h" struct ptrmarker { - uint32_t ptr_src; + u32 ptr_src; uintptr_t ptr_host; }; @@ -16,7 +16,7 @@ struct ptrmarker m_PtrMarkers[2048]; int m_NumPtrMarkers; int m_SizeGDLs; -static void add_marker(uint32_t ptr_src, uintptr_t ptr_host) +static void add_marker(u32 ptr_src, uintptr_t ptr_host) { if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { sysLogPrintf(LOG_ERROR, "[BG] Marker limit exceeded"); @@ -77,23 +77,23 @@ static void reset_markers() */ struct fileheader { - uint32_t primary_infsize; - uint32_t section1_cmpsize; - uint32_t primary_cmpsize; + u32 primary_infsize; + u32 section1_cmpsize; + u32 primary_cmpsize; }; struct sectionheader { - uint16_t infsize; - uint16_t cmpsize; + u16 infsize; + u16 cmpsize; }; struct n64_primaryheader { - uint32_t unused1; - uint32_t ptr_rooms; - uint32_t ptr_portals; - uint32_t ptr_bgcmds; - uint32_t ptr_lights; - uint32_t unused2; + u32 unused1; + u32 ptr_rooms; + u32 ptr_portals; + u32 ptr_bgcmds; + u32 ptr_lights; + u32 unused2; }; struct host_primaryheader { @@ -106,63 +106,63 @@ struct host_primaryheader { }; struct n64_room { - uint32_t ptr_gfxdata; - uint32_t pos[3]; - uint8_t br_light_min; - uint8_t br_light_max; + u32 ptr_gfxdata; + u32 pos[3]; + u8 br_light_min; + u8 br_light_max; }; struct host_room { uintptr_t ptr_gfxdata; - uint32_t pos[3]; - uint8_t br_light_min; - uint8_t br_light_max; + u32 pos[3]; + u8 br_light_min; + u8 br_light_max; }; struct portal { - uint16_t verticesoffset; - int16_t roomnum1; - int16_t roomnum2; - uint8_t flags; + u16 verticesoffset; + s16 roomnum1; + s16 roomnum2; + u8 flags; }; struct portalvertices { - uint8_t count; - uint32_t vertices[1][3]; + u8 count; + u32 vertices[1][3]; }; struct bgcmd { - uint8_t type; - uint8_t len; - int32_t param; + u8 type; + u8 len; + s32 param; }; struct light { - uint16_t roomnum; - uint16_t colour; - uint8_t brightness; - uint8_t sparkable : 1; - uint8_t healthy : 1; - uint8_t on : 1; - uint8_t sparking : 1; - uint8_t vulnerable : 1; - uint8_t brightnessmult; - int8_t dirx; - int8_t diry; - int8_t dirz; - int16_t bbox[4][3]; + u16 roomnum; + u16 colour; + u8 brightness; + u8 sparkable : 1; + u8 healthy : 1; + u8 on : 1; + u8 sparking : 1; + u8 vulnerable : 1; + u8 brightnessmult; + s8 dirx; + s8 diry; + s8 dirz; + s16 bbox[4][3]; }; struct n64_roomblock { - uint8_t type; - uint32_t ptr_next; - uint32_t ptr_gdl; - uint32_t ptr_vertices; - uint32_t ptr_colours; + u8 type; + u32 ptr_next; + u32 ptr_gdl; + u32 ptr_vertices; + u32 ptr_colours; }; struct host_roomblock { - uint8_t type; + u8 type; uintptr_t ptr_next; uintptr_t ptr_gdl; uintptr_t ptr_vertices; @@ -170,14 +170,14 @@ struct host_roomblock { }; struct n64_roomgfxdata { - uint32_t ptr_vertices; - uint32_t ptr_colours; - uint32_t ptr_opablocks; - uint32_t ptr_xlublocks; - int16_t lightsindex; - int16_t numlights; - int16_t numvertices; - int16_t numcolours; + u32 ptr_vertices; + u32 ptr_colours; + u32 ptr_opablocks; + u32 ptr_xlublocks; + s16 lightsindex; + s16 numlights; + s16 numvertices; + s16 numcolours; // roomblocks[] }; @@ -186,26 +186,26 @@ struct host_roomgfxdata { uintptr_t ptr_colours; uintptr_t ptr_opablocks; uintptr_t ptr_xlublocks; - int16_t lightsindex; - int16_t numlights; - int16_t numvertices; - int16_t numcolours; + s16 lightsindex; + s16 numlights; + s16 numvertices; + s16 numcolours; // roomblocks[] }; struct vtx { - int16_t coord[3]; - uint8_t flag; - uint8_t color; - uint16_t s; - uint16_t t; + s16 coord[3]; + u8 flag; + u8 color; + u16 s; + u16 t; }; int m_NumRooms; -uint32_t m_AllocSizes[512]; +u32 m_AllocSizes[512]; -static void convert_primary_rooms(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_primary_rooms(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { struct n64_room *n64_rooms = (struct n64_room *) &src[*srcpos]; struct host_room *host_rooms = (struct host_room *) &dst[*dstpos]; @@ -229,7 +229,7 @@ static void convert_primary_rooms(uint8_t *dst, uint32_t *dstpos, uint8_t *src, *dstpos += sizeof(*host_rooms) * (m_NumRooms +2); } -static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t *src_portalvtxs, uint32_t *dst_portalvtxs) +static void convert_primary_portals(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 *src_portalvtxs, u32 *dst_portalvtxs) { struct portal *n64_portals = (struct portal *) &src[*srcpos]; struct portal *host_portals = (struct portal *) &dst[*dstpos]; @@ -274,7 +274,7 @@ static void convert_primary_portals(uint8_t *dst, uint32_t *dstpos, uint8_t *src } } -static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t dst_portalvtxs, uint32_t src_portalvtxs) +static void convert_primary_bgcmds(u8 *dst, u32 *dstpos, u8 *src, u32 dst_portalvtxs, u32 src_portalvtxs) { struct bgcmd *n64_cmds = (struct bgcmd *) src; struct bgcmd *host_cmds = (struct bgcmd *) &dst[*dstpos]; @@ -292,7 +292,7 @@ static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, host_cmds[i].param = srctodst32(n64_cmds[i].param); if (host_cmds[i].type == 0x64) { - uint32_t offset = host_cmds[i].param - src_portalvtxs; + u32 offset = host_cmds[i].param - src_portalvtxs; host_cmds[i].param = dst_portalvtxs + offset; } } @@ -300,7 +300,7 @@ static void convert_primary_bgcmds(uint8_t *dst, uint32_t *dstpos, uint8_t *src, *dstpos += sizeof(*host_cmds) * num_cmds; } -static void convert_primary_lights(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t end) +static void convert_primary_lights(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 end) { struct light *n64_lights = (struct light *) &src[*srcpos]; struct light *host_lights = (struct light *) &dst[*dstpos]; @@ -347,11 +347,11 @@ void relink_ptr(uintptr_t** ptr) *ptr = marker->ptr_host; } -static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_t infsize, uint32_t src_ofs) +static u32 convert_section1_roomgfxdata(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) { reset_markers(); - uint32_t dst_roomoffset = src_ofs; + u32 dst_roomoffset = src_ofs; uintptr_t gdls_addr[64]; int numgdls = 0; @@ -407,8 +407,8 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_ // block coords for (size_t i = 0; i < ncoords; i++) { - uint32_t *src_coord = (uint32_t*)(src + curpos_src); - uint32_t *dst_coord = (uint32_t*)(dst + curpos_dst); + u32 *src_coord = (u32*)(src + curpos_src); + u32 *dst_coord = (u32*)(dst + curpos_dst); dst_coord[0] = srctoh32(src_coord[0]); dst_coord[1] = srctoh32(src_coord[1]); @@ -420,8 +420,8 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_ add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - curpos_src += 6 * sizeof(uint32_t); - curpos_dst += 6 * sizeof(uint32_t); + curpos_src += 6 * sizeof(u32); + curpos_dst += 6 * sizeof(u32); } curpos_dst = ALIGN8(curpos_dst); @@ -492,8 +492,8 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_ if (block->type == BLOCK_LEAF) { relink_ptr(&block->ptr_gdl); - uint32_t offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; - uint32_t offset_col = block->ptr_colours - ptr_src_colors - src_ofs; + u32 offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; + u32 offset_col = block->ptr_colours - ptr_src_colors - src_ofs; block->ptr_vertices = ptr_dst_vertices + offset_vtx; block->ptr_colours = ptr_dst_colors + offset_col; @@ -513,17 +513,17 @@ static uint32_t convert_section1_roomgfxdata(uint8_t *dst, uint8_t *src, uint32_ return curpos_dst; } -static uint32_t convert_section1(uint8_t *dst, uint8_t *src, uint32_t ofs) +static u32 convert_section1(u8 *dst, u8 *src, u32 ofs) { // Convert primary - uint32_t srcpos = 0; - uint32_t dstpos = 0; + u32 srcpos = 0; + u32 dstpos = 0; struct host_primaryheader *host_primary_header = (struct host_primaryheader *) dst; struct n64_primaryheader *n64_primary_header = (struct n64_primaryheader *) src; srcpos += sizeof(struct n64_primaryheader); dstpos += sizeof(*host_primary_header); - uint32_t src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - ofs; + u32 src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - ofs; host_primary_header->unused1 = 0; host_primary_header->unused2 = 0; @@ -539,7 +539,7 @@ static uint32_t convert_section1(uint8_t *dst, uint8_t *src, uint32_t ofs) host_primary_header->ptr_portals = dstpos + ofs; srcpos = srctodst32(n64_primary_header->ptr_portals) - ofs; - uint32_t src_portalvtxs, dst_portalvtxs; + u32 src_portalvtxs, dst_portalvtxs; convert_primary_portals(dst, &dstpos, src, &srcpos, &src_portalvtxs, &dst_portalvtxs); host_primary_header->ptr_bgcmds = dstpos + ofs; @@ -548,11 +548,11 @@ static uint32_t convert_section1(uint8_t *dst, uint8_t *src, uint32_t ofs) return dstpos; } -static void convert_section2_texturenums(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos, uint32_t srclen) +static void convert_section2_texturenums(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 srclen) { - uint16_t *src_ids = (uint16_t *) &src[*srcpos]; - uint16_t *dst_ids = (uint16_t *) &dst[*dstpos]; - int count = srclen / sizeof(uint16_t); + u16 *src_ids = (u16 *) &src[*srcpos]; + u16 *dst_ids = (u16 *) &dst[*dstpos]; + int count = srclen / sizeof(u16); for (int i = 0; i < count; i++) { dst_ids[i] = srctodst16(src_ids[i]); @@ -562,10 +562,10 @@ static void convert_section2_texturenums(uint8_t *dst, uint32_t *dstpos, uint8_t *dstpos += srclen; } -static void convert_section3_bboxes(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_section3_bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { - int16_t *src_bboxes = (int16_t *) &src[*srcpos]; - int16_t *dst_bboxes = (int16_t *) &dst[*dstpos]; + s16 *src_bboxes = (s16 *) &src[*srcpos]; + s16 *dst_bboxes = (s16 *) &dst[*dstpos]; for (int i = 0; i < m_NumRooms; i++) { dst_bboxes[i * 6 + 0] = srctodst16(src_bboxes[i * 6 + 0]); @@ -576,23 +576,23 @@ static void convert_section3_bboxes(uint8_t *dst, uint32_t *dstpos, uint8_t *src dst_bboxes[i * 6 + 5] = srctodst16(src_bboxes[i * 6 + 5]); } - *srcpos += sizeof(int16_t) * 6 * (m_NumRooms - 1); - *dstpos += sizeof(int16_t) * 6 * (m_NumRooms - 1); + *srcpos += sizeof(s16) * 6 * (m_NumRooms - 1); + *dstpos += sizeof(s16) * 6 * (m_NumRooms - 1); } -static void convert_section3_allocsizes(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_section3_allocsizes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { - uint16_t *dst_sizes = (uint16_t *) &dst[*dstpos]; + u16 *dst_sizes = (u16 *) &dst[*dstpos]; for (int i = 0; i < m_NumRooms; i++) { dst_sizes[i] = (m_AllocSizes[i] - 0x100) / 0x10; } - *srcpos += sizeof(uint16_t) * (m_NumRooms - 1); - *dstpos += sizeof(uint16_t) * (m_NumRooms - 1); + *srcpos += sizeof(u16) * (m_NumRooms - 1); + *dstpos += sizeof(u16) * (m_NumRooms - 1); } -static void convert_section3_lightcounts(uint8_t *dst, uint32_t *dstpos, uint8_t *src, uint32_t *srcpos) +static void convert_section3_lightcounts(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { memcpy(&dst[*dstpos], &src[*srcpos], m_NumRooms); @@ -601,11 +601,11 @@ static void convert_section3_lightcounts(uint8_t *dst, uint32_t *dstpos, uint8_t } #ifdef PLATFORM_64BIT -void preprocessBgSection1(uint8_t *data, uint32_t size, uint32_t ofs) +void preprocessBgSection1(u8 *data, u32 size, u32 ofs) { - uint8_t *dst = sysMemZeroAlloc(size); + u8 *dst = sysMemZeroAlloc(size); - uint32_t newSize = convert_section1(dst, data, ofs); + u32 newSize = convert_section1(dst, data, ofs); if (newSize > size) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg file, size %d newsize %d", size, newSize); @@ -616,11 +616,11 @@ void preprocessBgSection1(uint8_t *data, uint32_t size, uint32_t ofs) sysMemFree(dst); } -uint32_t preprocessBgRoom(uint8_t *data, uint32_t size, uint32_t room_ofs) +u32 preprocessBgRoom(u8 *data, u32 size, u32 room_ofs) { size *= 2; - uint8_t *dst = sysMemZeroAlloc(size); - uint32_t newSize = convert_section1_roomgfxdata(dst, data, size, room_ofs); + u8 *dst = sysMemZeroAlloc(size); + u32 newSize = convert_section1_roomgfxdata(dst, data, size, room_ofs); if (newSize > size) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg room, size %d newsize %d", size, newSize); diff --git a/port/pdextract/ext_file_lang.c b/port/pdextract/ext_file_lang.c index 9764c3a24..d0dc74e7e 100644 --- a/port/pdextract/ext_file_lang.c +++ b/port/pdextract/ext_file_lang.c @@ -4,10 +4,10 @@ #include "common.h" #include "system.h" -static int get_next_nonzero(uint8_t *src, uint32_t offset, size_t len) +static int get_next_nonzero(u8 *src, u32 offset, size_t len) { - uint32_t *ptr = (uint32_t *) &src[offset]; - uint32_t *end = (uint32_t *) &src[len]; + u32 *ptr = (u32 *) &src[offset]; + u32 *end = (u32 *) &src[len]; while (ptr < end) { if (*ptr != 0) { @@ -20,21 +20,21 @@ static int get_next_nonzero(uint8_t *src, uint32_t offset, size_t len) return 0; } -static int get_num_strings(uint8_t *src, size_t len) +static int get_num_strings(u8 *src, size_t len) { - uint32_t ptr_table_len = get_next_nonzero(src, 0, len); + u32 ptr_table_len = get_next_nonzero(src, 0, len); if (ptr_table_len) { - return ptr_table_len / sizeof(uint32_t); + return ptr_table_len / sizeof(u32); } return 1; } -uint32_t convert_lang_file(uint8_t *dst, uint8_t *src, size_t srclen) +u32 convert_lang_file(u8 *dst, u8 *src, size_t srclen) { // Convert it - uint32_t *src_offsets = (uint32_t *) src; + u32 *src_offsets = (u32 *) src; size_t src_ptr_table_len = srctoh32(src_offsets[0]); size_t src_str_table_len = srclen - src_ptr_table_len; int num_strings = get_num_strings(src, srclen); @@ -46,14 +46,14 @@ uint32_t convert_lang_file(uint8_t *dst, uint8_t *src, size_t srclen) uintptr_t *dst_offsets = (uintptr_t *) dst; for (int i = 0; i < num_strings; i++) { - uint32_t src_offset = srctoh32(src_offsets[i]); + u32 src_offset = srctoh32(src_offsets[i]); if (src_offset) { // Write pointer dst_offsets[i] = htodst32(cur_dst_offset); // Write string - uint32_t end = get_next_nonzero(src, (i + 1) * 4, num_strings * 4); + u32 end = get_next_nonzero(src, (i + 1) * 4, num_strings * 4); if (!end) { end = srclen; @@ -73,11 +73,11 @@ uint32_t convert_lang_file(uint8_t *dst, uint8_t *src, size_t srclen) return ALIGN16(cur_dst_offset); } -uint8_t *preprocessLangFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) { - uint32_t newSizeEstimated = (uint32_t)(size * 1.3); - uint8_t *dst = sysMemZeroAlloc(newSizeEstimated); +u8 *preprocessLangFile_x64(u8 *data, u32 size, u32 *outSize) { + u32 newSizeEstimated = (u32)(size * 1.3); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); - uint32_t newSize = convert_lang_file(dst, data, size); + u32 newSize = convert_lang_file(dst, data, size); if (newSize > newSizeEstimated) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a lang file, size %d newsize %d", size, newSize); diff --git a/port/pdextract/ext_file_model.c b/port/pdextract/ext_file_model.c index aa8e29321..3ce24b05d 100644 --- a/port/pdextract/ext_file_model.c +++ b/port/pdextract/ext_file_model.c @@ -29,9 +29,9 @@ enum contenttype { }; struct marker { - uint32_t src_offset; - uint32_t dst_offset; - uint32_t parent_src_offset; + u32 src_offset; + u32 dst_offset; + u32 parent_src_offset; enum contenttype type; }; @@ -90,40 +90,40 @@ int m_NumMarkers; #define MODELNODETYPE_0200 0x0200 struct src_modeldef { - uint32_t ptr_rootnode; - uint32_t ptr_skel; - uint32_t ptr_parts; - int16_t numparts; - int16_t nummatrices; - uint32_t scale; - uint16_t rwdatalen; - uint16_t numtexconfigs; - uint32_t ptr_texconfigs; + u32 ptr_rootnode; + u32 ptr_skel; + u32 ptr_parts; + s16 numparts; + s16 nummatrices; + u32 scale; + u16 rwdatalen; + u16 numtexconfigs; + u32 ptr_texconfigs; }; struct dst_modeldef { uintptr_t ptr_rootnode; uintptr_t ptr_skel; uintptr_t ptr_parts; - int16_t numparts; - int16_t nummatrices; - uint32_t scale; - uint16_t rwdatalen; - uint16_t numtexconfigs; + s16 numparts; + s16 nummatrices; + u32 scale; + u16 rwdatalen; + u16 numtexconfigs; uintptr_t ptr_texconfigs; }; struct src_modelnode { - uint16_t type; - uint32_t ptr_rodata; - uint32_t ptr_parent; - uint32_t ptr_next; - uint32_t ptr_prev; - uint32_t ptr_child; + u16 type; + u32 ptr_rodata; + u32 ptr_parent; + u32 ptr_next; + u32 ptr_prev; + u32 ptr_child; }; struct dst_modelnode { - uint16_t type; + u16 type; uintptr_t ptr_rodata; uintptr_t ptr_parent; uintptr_t ptr_next; @@ -132,26 +132,26 @@ struct dst_modelnode { }; struct generic_rodata_chrinfo { - uint16_t animpart; - int16_t mtxindex; - uint32_t unk04; - uint16_t rwdataindex; + u16 animpart; + s16 mtxindex; + u32 unk04; + u16 rwdataindex; }; struct generic_rodata_position { - uint32_t pos[3]; - uint16_t part; - int16_t mtxindexes[3]; - uint32_t drawdist; + u32 pos[3]; + u16 part; + s16 mtxindexes[3]; + u32 drawdist; }; struct src_rodata_gundl { - uint32_t ptr_opagdl; - uint32_t ptr_xlugdl; - uint32_t ptr_baseaddr; - uint32_t ptr_vertices; - int16_t numvertices; - int16_t unk12; + u32 ptr_opagdl; + u32 ptr_xlugdl; + u32 ptr_baseaddr; + u32 ptr_vertices; + s16 numvertices; + s16 unk12; }; struct dst_rodata_gundl { @@ -159,130 +159,130 @@ struct dst_rodata_gundl { uintptr_t ptr_xlugdl; uintptr_t ptr_baseaddr; uintptr_t ptr_vertices; - int16_t numvertices; - int16_t unk12; + s16 numvertices; + s16 unk12; }; struct src_rodata_distance { - uint32_t near; - uint32_t far; - uint32_t ptr_target; - uint16_t rwdataindex; + u32 near; + u32 far; + u32 ptr_target; + u16 rwdataindex; }; struct dst_rodata_distance { - uint32_t near; - uint32_t far; + u32 near; + u32 far; uintptr_t ptr_target; - uint16_t rwdataindex; + u16 rwdataindex; }; struct src_rodata_reorder { - uint32_t unk00; - uint32_t unk04; - uint32_t unk08; - uint32_t unk0c[3]; - uint32_t ptr_node_unk18; - uint32_t ptr_node_unk1c; - int16_t side; - uint16_t rwdataindex; + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c[3]; + u32 ptr_node_unk18; + u32 ptr_node_unk1c; + s16 side; + u16 rwdataindex; }; struct dst_rodata_reorder { - uint32_t unk00; - uint32_t unk04; - uint32_t unk08; - uint32_t unk0c[3]; + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c[3]; uintptr_t ptr_node_unk18; uintptr_t ptr_node_unk1c; - int16_t side; - uint16_t rwdataindex; + s16 side; + u16 rwdataindex; }; struct generic_rodata_bbox { - int32_t hitpart; - uint32_t bbox[6]; + s32 hitpart; + u32 bbox[6]; }; struct src_rodata_chrgunfire { - uint32_t pos[3]; - uint32_t dim[3]; - uint32_t ptr_texture; - uint32_t unk1c; - uint16_t rwdataindex; - uint32_t ptr_baseaddr; + u32 pos[3]; + u32 dim[3]; + u32 ptr_texture; + u32 unk1c; + u16 rwdataindex; + u32 ptr_baseaddr; }; struct dst_rodata_chrgunfire { - uint32_t pos[3]; - uint32_t dim[3]; + u32 pos[3]; + u32 dim[3]; uintptr_t ptr_texture; - uint32_t unk1c; - uint16_t rwdataindex; + u32 unk1c; + u16 rwdataindex; uintptr_t ptr_baseaddr; }; struct src_rodata_type11 { - uint32_t unk00; - uint32_t unk04; - uint32_t unk08; - uint32_t unk0c; - uint32_t unk10; - uint32_t ptr_unk14; + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c; + u32 unk10; + u32 ptr_unk14; }; struct dst_rodata_type11 { - uint32_t unk00; - uint32_t unk04; - uint32_t unk08; - uint32_t unk0c; - uint32_t unk10; + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c; + u32 unk10; uintptr_t ptr_unk14; }; struct src_rodata_toggle { - uint32_t ptr_target; - uint16_t rwdataindex; + u32 ptr_target; + u16 rwdataindex; }; struct dst_rodata_toggle { uintptr_t ptr_target; - uint16_t rwdataindex; + u16 rwdataindex; }; struct generic_rodata_positionheld { - uint32_t pos[3]; - int16_t mtxindex; - uint32_t unk10; + u32 pos[3]; + s16 mtxindex; + u32 unk10; }; struct src_rodata_stargunfire { - uint32_t unk00; - uint32_t ptr_vertices; - uint32_t ptr_gdl; - uint32_t ptr_baseaddr; + u32 unk00; + u32 ptr_vertices; + u32 ptr_gdl; + u32 ptr_baseaddr; }; struct dst_rodata_stargunfire { - uint32_t unk00; + u32 unk00; uintptr_t ptr_vertices; uintptr_t ptr_gdl; uintptr_t ptr_baseaddr; }; struct generic_rodata_headspot { - uint16_t rwdataindex; + u16 rwdataindex; }; struct src_rodata_dl { - uint32_t ptr_opagdl; - uint32_t ptr_xlugdl; - uint32_t ptr_colours; - uint32_t ptr_vertices; // colours follow this array - int16_t numvertices; - int16_t mcount; - uint16_t rwdataindex; - uint16_t numcolours; + u32 ptr_opagdl; + u32 ptr_xlugdl; + u32 ptr_colours; + u32 ptr_vertices; // colours follow this array + s16 numvertices; + s16 mcount; + u16 rwdataindex; + u16 numcolours; }; struct dst_rodata_dl { @@ -290,42 +290,42 @@ struct dst_rodata_dl { uintptr_t ptr_xlugdl; uintptr_t ptr_colours; uintptr_t ptr_vertices; // colours follow this array - int16_t numvertices; - int16_t mcount; - uint16_t rwdataindex; - uint16_t numcolours; + s16 numvertices; + s16 mcount; + u16 rwdataindex; + u16 numcolours; }; struct generic_rodata_type19 { - uint32_t numvertices; - uint32_t vertices[3]; + u32 numvertices; + u32 vertices[3]; }; struct src_texconfig { - uint32_t ptr; - uint8_t width; - uint8_t height; - uint8_t level; - uint8_t format; - uint8_t depth; - uint8_t s; - uint8_t t; - uint8_t unk0b; + u32 ptr; + u8 width; + u8 height; + u8 level; + u8 format; + u8 depth; + u8 s; + u8 t; + u8 unk0b; }; struct dst_texconfig { uintptr_t ptr; - uint8_t width; - uint8_t height; - uint8_t level; - uint8_t format; - uint8_t depth; - uint8_t s; - uint8_t t; - uint8_t unk0b; + u8 width; + u8 height; + u8 level; + u8 format; + u8 depth; + u8 s; + u8 t; + u8 unk0b; }; -static struct marker *find_marker(uint32_t src_offset) +static struct marker *find_marker(u32 src_offset) { for (int i = 0; i < m_NumMarkers; i++) { if (m_Markers[i].src_offset == src_offset) { @@ -336,7 +336,7 @@ static struct marker *find_marker(uint32_t src_offset) return NULL; } -static void set_marker(uint32_t src_offset, enum contenttype type, uint32_t parent_src_offset) +static void set_marker(u32 src_offset, enum contenttype type, u32 parent_src_offset) { if (src_offset == 0) { return; @@ -388,7 +388,7 @@ enum contenttype m_NodeTypeToContentType[] = { /*0x19*/ CT_RODATA_19, }; -static void populate_markers(uint8_t *src) +static void populate_markers(u8 *src) { m_NumMarkers = 0; @@ -398,13 +398,13 @@ static void populate_markers(uint8_t *src) struct marker *marker = &m_Markers[i]; void *src_thing = &src[marker->src_offset]; int numvtx = 0; - uint32_t colstart = 0; + u32 colstart = 0; switch (marker->type) { case CT_MODELDEF: struct src_modeldef *src_modeldef = src_thing; int num_texconfigs = srctoh16(src_modeldef->numtexconfigs); - uint32_t texconfigpos = srctoh32(src_modeldef->ptr_texconfigs); + u32 texconfigpos = srctoh32(src_modeldef->ptr_texconfigs); set_marker(srctoh32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); set_marker(srctoh32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); @@ -414,7 +414,7 @@ static void populate_markers(uint8_t *src) break; case CT_NODE: struct src_modelnode *src_node = src_thing; - uint32_t node_type = srctoh16(src_node->type) & 0xff; + u32 node_type = srctoh16(src_node->type) & 0xff; set_marker(srctoh32(src_node->ptr_rodata), m_NodeTypeToContentType[node_type], marker->src_offset); set_marker(srctoh32(src_node->ptr_parent), CT_NODE, marker->src_offset); set_marker(srctoh32(src_node->ptr_next), CT_NODE, marker->src_offset); @@ -429,7 +429,7 @@ static void populate_markers(uint8_t *src) break; case CT_PARTS: struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - uint32_t *src_parts = (uint32_t *) src_thing; + u32 *src_parts = (u32 *) src_thing; int num_parts = srctoh16(src_modeldef2->numparts); for (int i = 0; i < num_parts; i++) { @@ -503,7 +503,7 @@ static void populate_markers(uint8_t *src) static void sort_markers(void) { for (int i = 0; i < m_NumMarkers - 1; i++) { - uint32_t min_offset = 0xffffffff; + u32 min_offset = 0xffffffff; int min_index = -1; for (int j = i + 1; j < m_NumMarkers; j++) { @@ -521,15 +521,15 @@ static void sort_markers(void) } } -static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_len) +static u32 convert_content(u8 *dst, u8 *src, u32 src_file_len) { - uint32_t dstpos = 0; + u32 dstpos = 0; for (int i = 0; i < m_NumMarkers; i++) { struct marker *marker = &m_Markers[i]; void *src_thing = &src[marker->src_offset]; - uint32_t src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; - uint32_t src_len = src_end - marker->src_offset; + u32 src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; + u32 src_len = src_end - marker->src_offset; dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].before); @@ -584,16 +584,16 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le break; case CT_PARTS: struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - uint32_t *src_parts = (uint32_t *) src_thing; + u32 *src_parts = (u32 *) src_thing; uintptr_t *dst_parts = (uintptr_t *) dst_thing; int num_parts = srctoh16(src_modeldef2->numparts); - uint16_t *src_nums = (uint16_t *) &src_parts[num_parts]; - uint16_t *dst_nums = (uint16_t *) &dst_parts[num_parts]; + u16 *src_nums = (u16 *) &src_parts[num_parts]; + u16 *dst_nums = (u16 *) &dst_parts[num_parts]; for (int i = 0; i < num_parts; i++) { dst_nums[i] = srctodst16(src_nums[i]); } - dstpos += num_parts * sizeof(uintptr_t) + num_parts * sizeof(uint16_t); + dstpos += num_parts * sizeof(uintptr_t) + num_parts * sizeof(u16); if (num_parts) { dstpos = ALIGN8(dstpos); } @@ -604,8 +604,8 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le break; case CT_GDL: struct marker *parent = find_marker(marker->parent_src_offset); - uint32_t src_vtx; - uint32_t dst_vtx; + u32 src_vtx; + u32 dst_vtx; if (parent->type == CT_RODATA_GUNDL) { struct src_rodata_gundl *src_rodata = (struct src_rodata_gundl *) &src[parent->src_offset]; @@ -754,18 +754,18 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le case CT_RODATA_19: struct generic_rodata_type19 *src_type19 = src_thing; struct generic_rodata_type19 *dst_type19 = dst_thing; - uint32_t *src_vertices = src_thing + sizeof(uint32_t); - uint32_t *dst_vertices = dst_thing + sizeof(uint32_t); + u32 *src_vertices = src_thing + sizeof(u32); + u32 *dst_vertices = dst_thing + sizeof(u32); int num_vertices = srctoh32(src_type19->numvertices); dst_type19->numvertices = htodst32(num_vertices); - dstpos += sizeof(uint32_t); + dstpos += sizeof(u32); for (int i = 0; i < num_vertices; i++) { dst_vertices[i * 3 + 0] = srctodst32(src_vertices[i * 3 + 0]); dst_vertices[i * 3 + 1] = srctodst32(src_vertices[i * 3 + 1]); dst_vertices[i * 3 + 2] = srctodst32(src_vertices[i * 3 + 2]); - dstpos += sizeof(uint32_t) * 3; + dstpos += sizeof(u32) * 3; } break; } @@ -776,7 +776,7 @@ static uint32_t convert_content(uint8_t *dst, uint8_t *src, uint32_t src_file_le return dstpos; } -static uint32_t resolve_pointer(uint32_t src_offset) +static u32 resolve_pointer(u32 src_offset) { if (src_offset == 0) { return 0; @@ -786,7 +786,7 @@ static uint32_t resolve_pointer(uint32_t src_offset) return marker ? (0x05000000 | marker->dst_offset) : 0; } -static void relink_pointers(uint8_t *dst, uint8_t *src) +static void relink_pointers(u8 *dst, u8 *src) { for (int i = 0; i < m_NumMarkers; i++) { struct marker *marker = &m_Markers[i]; @@ -820,7 +820,7 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) break; case CT_PARTS: struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - uint32_t *src_parts = (uint32_t *) src_thing; + u32 *src_parts = (u32 *) src_thing; uintptr_t *dst_parts = (uintptr_t *) dst_thing; int num_parts = srctoh16(src_modeldef2->numparts); @@ -918,9 +918,9 @@ static void relink_pointers(uint8_t *dst, uint8_t *src) } } -static int convert_model(uint8_t *dst, uint8_t *src, uint32_t srclen) +static int convert_model(u8 *dst, u8 *src, u32 srclen) { - uint32_t dstpos; + u32 dstpos; populate_markers(src); sort_markers(); @@ -931,14 +931,14 @@ static int convert_model(uint8_t *dst, uint8_t *src, uint32_t srclen) return dstpos; } -uint8_t *preprocessModelFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) +u8 *preprocessModelFile_x64(u8 *data, u32 size, u32 *outSize) { gbi_reset(); - uint32_t newSizeEstimated = (uint32_t)(size * 1.7); - uint8_t *dst = sysMemZeroAlloc(newSizeEstimated); + u32 newSizeEstimated = (u32)(size * 1.7); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); - uint32_t newSize = convert_model(dst, data, size); + u32 newSize = convert_model(dst, data, size); if (newSize > newSizeEstimated) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); diff --git a/port/pdextract/ext_file_pads.c b/port/pdextract/ext_file_pads.c index 46bfa7187..bba3b6b2b 100644 --- a/port/pdextract/ext_file_pads.c +++ b/port/pdextract/ext_file_pads.c @@ -16,66 +16,66 @@ #define PADFLAG_HASBBOXDATA 0x0200 struct n64_header { - int32_t num_pads; - int32_t num_covers; - uint32_t ptr_waypoints; - uint32_t ptr_waygroups; - uint32_t ptr_cover; + s32 num_pads; + s32 num_covers; + u32 ptr_waypoints; + u32 ptr_waygroups; + u32 ptr_cover; }; struct host_header { - int32_t num_pads; - int32_t num_covers; + s32 num_pads; + s32 num_covers; uintptr_t ptr_waypoints; uintptr_t ptr_waygroups; uintptr_t ptr_cover; }; struct padheader { - uint32_t flags : 18; - uint32_t room : 10; - uint32_t liftnum : 4; + u32 flags : 18; + u32 room : 10; + u32 liftnum : 4; }; struct n64_waypoint { - int32_t padnum; - uint32_t ptr_neighbours; - int32_t groupnum; - int32_t step; + s32 padnum; + u32 ptr_neighbours; + s32 groupnum; + s32 step; }; struct host_waypoint { - int32_t padnum; + s32 padnum; uintptr_t ptr_neighbours; - int32_t groupnum; - int32_t step; + s32 groupnum; + s32 step; }; struct n64_waygroup { - uint32_t ptr_neighbours; - uint32_t ptr_waypoints; - int32_t step; + u32 ptr_neighbours; + u32 ptr_waypoints; + s32 step; }; struct host_waygroup { uintptr_t ptr_neighbours; uintptr_t ptr_waypoints; - int32_t step; + s32 step; }; struct coverdefinition { - uint32_t pos[3]; - uint32_t dir[3]; - uint16_t flags; - uint16_t unk1a; + u32 pos[3]; + u32 dir[3]; + u16 flags; + u16 unk1a; }; -static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int num_pads) +static int convert_pads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) { - uint16_t *src_offsets = (uint16_t *) &src[srcpos]; - uint16_t *dst_offsets = (uint16_t *) &dst[dstpos]; + u16 *src_offsets = (u16 *) &src[srcpos]; + u16 *dst_offsets = (u16 *) &dst[dstpos]; - dstpos += num_pads * sizeof(uint16_t); + dstpos += num_pads * sizeof(u16); for (int i = 0; i < num_pads; i++) { dstpos = ALIGN4(dstpos); @@ -84,19 +84,19 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int dst_offsets[i] = htodst16(dstpos); // Header - uint32_t n64_padheader = srctoh32(*(uint32_t *) &src[srcpos]); + u32 n64_padheader = srctoh32(*(u32 *) &src[srcpos]); struct padheader *host_padheader = (struct padheader *) &dst[dstpos]; - uint32_t flags = (n64_padheader >> 14) & 0x3ffff; + u32 flags = (n64_padheader >> 14) & 0x3ffff; - *(uint32_t*)host_padheader = htodst32(n64_padheader); + *(u32*)host_padheader = htodst32(n64_padheader); srcpos += sizeof(struct padheader); dstpos += sizeof(struct padheader); // Position if (flags & PADFLAG_INTPOS) { - int16_t *srcptr = (int16_t *) &src[srcpos]; - int16_t *dstptr = (int16_t *) &dst[dstpos]; + s16 *srcptr = (s16 *) &src[srcpos]; + s16 *dstptr = (s16 *) &dst[dstpos]; dstptr[0] = srctodst16(srcptr[0]); dstptr[1] = srctodst16(srcptr[1]); @@ -105,8 +105,8 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int srcpos += 8; dstpos += 8; } else { - uint32_t *srcptr = (uint32_t *) &src[srcpos]; - uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; dstptr[0] = srctodst32(srcptr[0]); dstptr[1] = srctodst32(srcptr[1]); @@ -118,8 +118,8 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int // Up if ((flags & (PADFLAG_UPALIGNTOX | PADFLAG_UPALIGNTOY | PADFLAG_UPALIGNTOZ)) == 0) { - uint32_t *srcptr = (uint32_t *) &src[srcpos]; - uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; dstptr[0] = srctodst32(srcptr[0]); dstptr[1] = srctodst32(srcptr[1]); @@ -131,8 +131,8 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int // Look if ((flags & (PADFLAG_LOOKALIGNTOX | PADFLAG_LOOKALIGNTOY | PADFLAG_LOOKALIGNTOZ)) == 0) { - uint32_t *srcptr = (uint32_t *) &src[srcpos]; - uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; dstptr[0] = srctodst32(srcptr[0]); dstptr[1] = srctodst32(srcptr[1]); @@ -144,8 +144,8 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int // Bbox if (flags & PADFLAG_HASBBOXDATA) { - uint32_t *srcptr = (uint32_t *) &src[srcpos]; - uint32_t *dstptr = (uint32_t *) &dst[dstpos]; + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; dstptr[0] = srctodst32(srcptr[0]); dstptr[1] = srctodst32(srcptr[1]); @@ -162,7 +162,7 @@ static int convert_pads(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int return dstpos; } -static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_waypoints(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_waypoint *n64_waypoints = (struct n64_waypoint *) &src[srcpos]; struct host_waypoint *host_waypoints = (struct host_waypoint *) &dst[dstpos]; @@ -172,7 +172,7 @@ static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) dstpos += (num_waypoints + 1) * sizeof(struct host_waypoint); - uint32_t *host_neighbours = (uint32_t *) &dst[dstpos]; + u32 *host_neighbours = (u32 *) &dst[dstpos]; int n = 0; for (int i = 0; i < num_waypoints; i++) { @@ -181,7 +181,7 @@ static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) host_waypoints[i].groupnum = srctodst32(n64_waypoints[i].groupnum); host_waypoints[i].step = 0; - uint32_t *n64_neighbours = (uint32_t *) &src[srctoh32(n64_waypoints[i].ptr_neighbours)]; + u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waypoints[i].ptr_neighbours)]; for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { host_neighbours[n++] = srctodst32(n64_neighbours[j]); @@ -201,7 +201,7 @@ static int convert_waypoints(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) return dstpos; } -static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) +static int convert_waygroups(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_waygroup *n64_waygroups = (struct n64_waygroup *) &src[srcpos]; struct host_waygroup *host_waygroups = (struct host_waygroup *) &dst[dstpos]; @@ -212,14 +212,14 @@ static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) dstpos += (num_waygroups + 1) * sizeof(struct host_waygroup); // Waygroups and child waypoints - uint32_t *host_waypoints = (uint32_t *) &dst[dstpos]; + u32 *host_waypoints = (u32 *) &dst[dstpos]; int n = 0; for (int i = 0; i < num_waygroups; i++) { host_waygroups[i].ptr_waypoints = htodst32(dstpos); host_waygroups[i].step = 0; - uint32_t *n64_waypoints = (uint32_t *) &src[srctoh32(n64_waygroups[i].ptr_waypoints)]; + u32 *n64_waypoints = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_waypoints)]; for (int j = 0; n64_waypoints[j] != 0xffffffff; j++) { host_waypoints[n++] = srctodst32(n64_waypoints[j]); @@ -236,13 +236,13 @@ static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) host_waygroups[num_waygroups].step = 0; // Waygroup neighbours - uint32_t *host_neighbours = (uint32_t *) &dst[dstpos]; + u32 *host_neighbours = (u32 *) &dst[dstpos]; n = 0; for (int i = 0; i < num_waygroups; i++) { host_waygroups[i].ptr_neighbours = htodst32(dstpos); - uint32_t *n64_neighbours = (uint32_t *) &src[srctoh32(n64_waygroups[i].ptr_neighbours)]; + u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_neighbours)]; for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { host_neighbours[n++] = srctodst32(n64_neighbours[j]); @@ -256,7 +256,7 @@ static int convert_waygroups(uint8_t *dst, int dstpos, uint8_t *src, int srcpos) return dstpos; } -static int convert_cover(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int num_covers) +static int convert_cover(u8 *dst, int dstpos, u8 *src, int srcpos, int num_covers) { struct coverdefinition *n64_covers = (struct coverdefinition *) &src[srcpos]; struct coverdefinition *host_covers = (struct coverdefinition *) &dst[dstpos]; @@ -277,7 +277,7 @@ static int convert_cover(uint8_t *dst, int dstpos, uint8_t *src, int srcpos, int return dstpos; } -static int convert_pads_file(uint8_t *dst, uint8_t *src) +static int convert_pads_file(u8 *dst, u8 *src) { int dstpos = 0; struct n64_header *n64_header = (struct n64_header *) src; diff --git a/port/pdextract/ext_file_tiles.c b/port/pdextract/ext_file_tiles.c index 4c2bf6b76..e5ca85454 100644 --- a/port/pdextract/ext_file_tiles.c +++ b/port/pdextract/ext_file_tiles.c @@ -6,37 +6,37 @@ struct tile { - uint8_t type; - uint8_t numvertices; - uint16_t flags; - uint16_t floortype; - uint8_t xmin; - uint8_t ymin; - uint8_t zmin; - uint8_t xmax; - uint8_t ymax; - uint8_t zmax; - uint16_t floorcol; + u8 type; + u8 numvertices; + u16 flags; + u16 floortype; + u8 xmin; + u8 ymin; + u8 zmin; + u8 xmax; + u8 ymax; + u8 zmax; + u16 floorcol; }; -uint32_t convert_tiles(uint8_t *dst, uint8_t *src, size_t srclen) +u32 convert_tiles(u8 *dst, u8 *src, size_t srclen) { - int num_rooms = srctoh32(*(uint32_t *) src); + int num_rooms = srctoh32(*(u32 *) src); size_t src_ptr_table_len = (num_rooms + 1) * 4; - size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(uint32_t); + size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(u32); - uint32_t *src_offsets = (uint32_t *) &src[4]; + u32 *src_offsets = (u32 *) &src[4]; size_t data_len = srclen - src_ptr_table_len - 4; - *(uint32_t *) dst = htodst32(num_rooms); + *(u32 *) dst = htodst32(num_rooms); - uint32_t *dst_offsets = (uint32_t *) (dst + sizeof(uint32_t)); - uint32_t cur_dst_offset = dst_ptr_table_len + sizeof(uint32_t); + u32 *dst_offsets = (u32 *) (dst + sizeof(u32)); + u32 cur_dst_offset = dst_ptr_table_len + sizeof(u32); - uint32_t cur_src_offset = srctoh32(src_offsets[0]); - uint32_t end_src_offset = srctoh32(src_offsets[num_rooms]); + u32 cur_src_offset = srctoh32(src_offsets[0]); + u32 end_src_offset = srctoh32(src_offsets[num_rooms]); int room = 0; while (1) { @@ -73,9 +73,9 @@ uint32_t convert_tiles(uint8_t *dst, uint8_t *src, size_t srclen) // Write tile vertices for (int i = 0; i < hosttile.numvertices; i++) { - *(int16_t *) &dst[cur_dst_offset + 0] = srctodst16(*(int16_t *) &src[cur_src_offset + 0]); - *(int16_t *) &dst[cur_dst_offset + 2] = srctodst16(*(int16_t *) &src[cur_src_offset + 2]); - *(int16_t *) &dst[cur_dst_offset + 4] = srctodst16(*(int16_t *) &src[cur_src_offset + 4]); + *(s16 *) &dst[cur_dst_offset + 0] = srctodst16(*(s16 *) &src[cur_src_offset + 0]); + *(s16 *) &dst[cur_dst_offset + 2] = srctodst16(*(s16 *) &src[cur_src_offset + 2]); + *(s16 *) &dst[cur_dst_offset + 4] = srctodst16(*(s16 *) &src[cur_src_offset + 4]); cur_dst_offset += 6; cur_src_offset += 6; } @@ -84,11 +84,11 @@ uint32_t convert_tiles(uint8_t *dst, uint8_t *src, size_t srclen) return ALIGN16(cur_dst_offset); } -uint8_t *preprocessTilesFile_x64(uint8_t *data, uint32_t size, uint32_t *outSize) +u8 *preprocessTilesFile_x64(u8 *data, u32 size, u32 *outSize) { - uint8_t *dst = sysMemZeroAlloc(size); + u8 *dst = sysMemZeroAlloc(size); - uint32_t newSize = convert_tiles(dst, data, size); + u32 newSize = convert_tiles(dst, data, size); if (newSize > size) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a tiles file, size %d newsize %d", size, newSize); diff --git a/port/pdextract/ext_fonts.c b/port/pdextract/ext_fonts.c index eddddedff..6d8c49bdf 100644 --- a/port/pdextract/ext_fonts.c +++ b/port/pdextract/ext_fonts.c @@ -7,44 +7,44 @@ #include "system.h" struct n64fontchar { - uint8_t index; - int8_t baseline; - uint8_t height; - uint8_t width; - int32_t kerningindex; - uint32_t pixeldata; + u8 index; + s8 baseline; + u8 height; + u8 width; + s32 kerningindex; + u32 pixeldata; }; struct hostfontchar { - uint8_t index; - int8_t baseline; - uint8_t height; - uint8_t width; - int32_t kerningindex; + u8 index; + s8 baseline; + u8 height; + u8 width; + s32 kerningindex; uintptr_t pixeldata; }; struct n64fontcharjpn { - uint16_t index; - int8_t baseline; - uint8_t height; - uint8_t width; - int16_t kerningindex; - uint32_t pixeldata; + u16 index; + s8 baseline; + u8 height; + u8 width; + s16 kerningindex; + u32 pixeldata; }; struct hostfontcharjpn { - uint16_t index; - int8_t baseline; - uint8_t height; - uint8_t width; - int16_t kerningindex; + u16 index; + s8 baseline; + u8 height; + u8 width; + s16 kerningindex; uintptr_t pixeldata; }; struct fontdef { const char *name; - uint32_t offsets[3]; + u32 offsets[3]; int pal_extra_chars; }; @@ -64,24 +64,24 @@ u8* preprocessFont_x64(u8 *src, u32 srclen, u32 *outSize) #endif size_t dstlen = srclen - (num_chars * sizeof(struct n64fontchar)) + (num_chars * sizeof(struct hostfontchar)) + 0x20; - uint8_t* dst = sysMemZeroAlloc(dstlen); + u8* dst = sysMemZeroAlloc(dstlen); // Kerning table - int32_t *src_kerning_table = (int32_t *)src; - int32_t *dst_kerning_table = (int32_t *)dst; + s32 *src_kerning_table = (s32 *)src; + s32 *dst_kerning_table = (s32 *)dst; for (int i = 0; i < 13 * 13; i++) { dst_kerning_table[i] = srctodst32(src_kerning_table[i]); } - uint32_t src_offset = ALIGN(13 * 13 * 4, sizeof(uint32_t)); - uint32_t dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); + u32 src_offset = ALIGN(13 * 13 * 4, sizeof(u32)); + u32 dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); // Character table #if VERSION == VERSION_JPN_FINAL struct n64fontcharjpn *src_char_table = (struct n64fontcharjpn *) &src[src_offset]; struct hostfontcharjpn *dst_char_table = (struct hostfontcharjpn *) &dst[dst_offset]; - uint32_t diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); + u32 diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); for (int i = 0; i < num_chars; i++) { dst_char_table[i].index = srctodst16(src_char_table[i].index); @@ -97,7 +97,7 @@ u8* preprocessFont_x64(u8 *src, u32 srclen, u32 *outSize) #else struct n64fontchar *src_char_table = (struct n64fontchar *) &src[src_offset]; struct hostfontchar *dst_char_table = (struct hostfontchar *) &dst[dst_offset]; - uint32_t diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); + u32 diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); for (int i = 0; i < num_chars; i++) { dst_char_table[i].index = src_char_table[i].index; diff --git a/port/pdextract/util_gbi.c b/port/pdextract/util_gbi.c index 64d541331..e41080aea 100644 --- a/port/pdextract/util_gbi.c +++ b/port/pdextract/util_gbi.c @@ -12,23 +12,23 @@ #endif struct vtx { - int16_t x; - int16_t y; - int16_t z; - uint8_t flags; - uint8_t colour; - int16_t s; - int16_t t; + s16 x; + s16 y; + s16 z; + u8 flags; + u8 colour; + s16 s; + s16 t; }; struct texaddr { - uint32_t src; - uint32_t dst; + u32 src; + u32 dst; }; -uint32_t m_Segments[16]; -uint32_t m_SrcVtxOffset; -uint32_t m_DstVtxOffset; +u32 m_Segments[16]; +u32 m_SrcVtxOffset; +u32 m_DstVtxOffset; struct texaddr m_TexAddrs[64]; int m_NumTexAddr; @@ -44,24 +44,24 @@ void gbi_reset(void) m_NumTexAddr = 0; } -void gbi_set_segment(int segment, uint32_t offset) +void gbi_set_segment(int segment, u32 offset) { m_Segments[segment] = offset & 0x00ffffff; } -void gbi_set_vtx(uint32_t src_offset, uint32_t dst_offset) +void gbi_set_vtx(u32 src_offset, u32 dst_offset) { m_SrcVtxOffset = src_offset & 0x00ffffff; m_DstVtxOffset = dst_offset & 0x00ffffff; } -void gbi_add_tex_addr(uint32_t src_offset, uint32_t dst_offset) +void gbi_add_tex_addr(u32 src_offset, u32 dst_offset) { m_TexAddrs[m_NumTexAddr].src = src_offset & 0x00ffffff; m_TexAddrs[m_NumTexAddr++].dst = dst_offset & 0x00ffffff; } -uint32_t gbi_find_tex_addr(uint32_t src_offset) +u32 gbi_find_tex_addr(u32 src_offset) { for (int i = 0; i < m_NumTexAddr; i++) { if (m_TexAddrs[i].src == src_offset) @@ -71,7 +71,7 @@ uint32_t gbi_find_tex_addr(uint32_t src_offset) return 0; } -void gbi_convert_vtx(uint8_t *dst, uint32_t offset, int count) +void gbi_convert_vtx(u8 *dst, u32 offset, int count) { if (!offset) return; struct vtx* vtxs = (struct vtx*)(dst + offset); @@ -117,10 +117,10 @@ void gbi_convert_vtx(uint8_t *dst, uint32_t offset, int count) * Segment 5 is the start of the model file. The data in these files shifts * depending on the pointer size, so this function adjusts the offset accordingly. */ -static uint64_t gbi_rewrite_addr(uint64_t cmd, uint8_t opcode) +static uint64_t gbi_rewrite_addr(uint64_t cmd, u8 opcode) { - uint8_t segment = (cmd & 0x0f000000) >> 24; - uint32_t offset = cmd & 0x00ffffff; + u8 segment = (cmd & 0x0f000000) >> 24; + u32 offset = cmd & 0x00ffffff; if (segment == 5) { if (opcode == 0xfd) { @@ -139,7 +139,7 @@ static uint64_t gbi_rewrite_addr(uint64_t cmd, uint8_t opcode) return (cmd & 0xffffffffff000000) | offset; } -void gbi_gdl_rewrite_addrs(uint8_t *dst, uint32_t offset) +void gbi_gdl_rewrite_addrs(u8 *dst, u32 offset) { if (!offset) return; @@ -152,7 +152,7 @@ void gbi_gdl_rewrite_addrs(uint8_t *dst, uint32_t offset) cmd = *cmds; if (CMD_HAS_ADDR((cmd << 32))) { - uint8_t opcode = (cmd >> 24) & 0xff; + u8 opcode = (cmd >> 24) & 0xff; cmds[1] = gbi_rewrite_addr(cmds[1], opcode); } @@ -164,7 +164,7 @@ void gbi_gdl_rewrite_addrs(uint8_t *dst, uint32_t offset) } while (!CMD_IS_ENDDL((cmd << 32))); } -uint32_t gbi_convert_gdl(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, int segment_cmds) +u32 gbi_convert_gdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds) { dstpos = ALIGN8(dstpos); From 5795634b9c0e48b26d7cec4e6a71c9c81b610ff3 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 17:32:33 +0800 Subject: [PATCH 16/81] portx64: files/romdata: getEstimatedFileSize() so we can preallocate enough memory for files in x64 --- port/include/romdata.h | 12 +++- port/pdextract/ext_audio.c | 6 +- port/pdextract/ext_file_lang.c | 4 +- port/pdextract/ext_file_model.c | 4 +- port/pdextract/ext_file_pads.c | 4 +- port/pdextract/ext_file_tiles.c | 7 ++- port/pdextract/ext_setups.c | 9 ++- port/pdextract/util.c | 103 -------------------------------- port/src/romdata.c | 16 +++++ src/game/bg.c | 17 +++++- src/game/bondgun.c | 6 +- src/game/file.c | 14 +++-- src/game/lang.c | 14 +++-- src/game/langreset.c | 26 +++++--- src/game/menu.c | 6 +- src/game/modeldef.c | 2 +- src/game/player.c | 6 +- src/game/setup.c | 4 +- src/game/tilesreset.c | 2 +- src/include/game/file.h | 8 ++- 20 files changed, 122 insertions(+), 148 deletions(-) delete mode 100644 port/pdextract/util.c diff --git a/port/include/romdata.h b/port/include/romdata.h index d1d411f1e..da0d81da0 100644 --- a/port/include/romdata.h +++ b/port/include/romdata.h @@ -6,10 +6,19 @@ extern u8 *g_RomFile; extern u32 g_RomFileSize; +typedef enum { + FT_BG, + FT_TILES, + FT_LANG, + FT_SETUP, + FT_PADS, + FT_MODEL +} FileType; + s32 romdataInit(void); u8 *romdataFileLoad(s32 fileNum, u32 *outSize); -void romdataFilePreprocess(s32 fileNum, s32 loadType, u8 *data, u32 size); +void romdataFilePreprocess(s32 fileNum, s32 loadType, u8 *data, u32 size, u32 *outSize); void romdataFileFree(s32 fileNum); const char *romdataFileGetName(s32 fileNum); @@ -21,5 +30,6 @@ s32 romdataFileGetNumForName(const char *name); u8 *romdataSegGetData(const char *segName); u8 *romdataSegGetDataEnd(const char *segName); u32 romdataSegGetSize(const char *segName); +u32 romdataGetEstimatedFileSize(u32 size, FileType filetype); #endif diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c index f3dbc3f8a..a4992f1b8 100644 --- a/port/pdextract/ext_audio.c +++ b/port/pdextract/ext_audio.c @@ -1,7 +1,9 @@ #include #include #include + #include "common.h" +#include "system.h" enum { AL_ADPCM_WAVE = 0, @@ -414,8 +416,8 @@ static int convert_audio_bankfile(u8 *dst, u8 *src) u8 *preprocessALBankFile_x64(u8 *src, u32 size, u32 *outSize) { - size_t dstlen = size * 4; - u8 *dst = calloc(1, dstlen); + u32 dstlen = size * 4; + u8* dst = sysMemZeroAlloc(dstlen); *outSize = convert_audio_bankfile(dst, src); *outSize = ALIGN16(*outSize); diff --git a/port/pdextract/ext_file_lang.c b/port/pdextract/ext_file_lang.c index d0dc74e7e..b9cd46409 100644 --- a/port/pdextract/ext_file_lang.c +++ b/port/pdextract/ext_file_lang.c @@ -1,7 +1,9 @@ #include #include #include + #include "common.h" +#include "romdata.h" #include "system.h" static int get_next_nonzero(u8 *src, u32 offset, size_t len) @@ -74,7 +76,7 @@ u32 convert_lang_file(u8 *dst, u8 *src, size_t srclen) } u8 *preprocessLangFile_x64(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = (u32)(size * 1.3); + u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_LANG); u8 *dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convert_lang_file(dst, data, size); diff --git a/port/pdextract/ext_file_model.c b/port/pdextract/ext_file_model.c index 3ce24b05d..efef151f5 100644 --- a/port/pdextract/ext_file_model.c +++ b/port/pdextract/ext_file_model.c @@ -1,7 +1,9 @@ #include #include #include + #include "common.h" +#include "romdata.h" #include "system.h" enum contenttype { @@ -935,7 +937,7 @@ u8 *preprocessModelFile_x64(u8 *data, u32 size, u32 *outSize) { gbi_reset(); - u32 newSizeEstimated = (u32)(size * 1.7); + u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_MODEL); u8 *dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convert_model(dst, data, size); diff --git a/port/pdextract/ext_file_pads.c b/port/pdextract/ext_file_pads.c index bba3b6b2b..d9aae0fc4 100644 --- a/port/pdextract/ext_file_pads.c +++ b/port/pdextract/ext_file_pads.c @@ -1,7 +1,9 @@ #include #include #include + #include "common.h" +#include "romdata.h" #include "system.h" #define PADFLAG_INTPOS 0x0001 @@ -309,7 +311,7 @@ static int convert_pads_file(u8 *dst, u8 *src) } u8* preprocessPadsFile_x64(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = (u32)(size * 1.7); + u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_PADS); u8* dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convert_pads_file(dst, data); diff --git a/port/pdextract/ext_file_tiles.c b/port/pdextract/ext_file_tiles.c index e5ca85454..ce32f3954 100644 --- a/port/pdextract/ext_file_tiles.c +++ b/port/pdextract/ext_file_tiles.c @@ -1,7 +1,9 @@ #include #include #include + #include "common.h" +#include "romdata.h" #include "system.h" @@ -86,11 +88,12 @@ u32 convert_tiles(u8 *dst, u8 *src, size_t srclen) u8 *preprocessTilesFile_x64(u8 *data, u32 size, u32 *outSize) { - u8 *dst = sysMemZeroAlloc(size); + u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_TILES); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convert_tiles(dst, data, size); - if (newSize > size) { + if (newSize > newSizeEstimated) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a tiles file, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); } diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c index 9f0316370..345523990 100644 --- a/port/pdextract/ext_setups.c +++ b/port/pdextract/ext_setups.c @@ -4,11 +4,14 @@ #include "types.h" -#include "common.h" -#include "system.h" #include "assert.h" + +#include "common.h" #include "setups_decl.h" +#include "romdata.h" +#include "system.h" + static inline void convF32(f32 *dst, f32 src) { *(u32*)dst = srctoh32(*(u32*)&src); } static inline void convU32(u32 *dst, u32 src) { *dst = srctoh32(src); } @@ -1232,7 +1235,7 @@ void test_conv_functions() } u8 *preprocessSetupFile_x64(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = (u32)(size * 3.3); + u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_SETUP); u8 *dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convert_setup(dst, data, size); diff --git a/port/pdextract/util.c b/port/pdextract/util.c deleted file mode 100644 index 8cdcb58f3..000000000 --- a/port/pdextract/util.c +++ /dev/null @@ -1,103 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include - -FILE *openfile(char *filename) -{ - char path[1024]; - struct stat status; - - memcpy(path, filename, strlen(filename)); - dirname(path); - - while (stat(path, &status) == -1) { -// while (mkdir(path, 0755) == -1) { - while (mkdir(path) == -1) { - dirname(path); - } - - memcpy(path, filename, strlen(filename)); - dirname(path); - } - - FILE *fp = fopen(filename, "wb"); - - if (fp == NULL) { - fprintf(stderr, "Unable to open '%s' for writing\n", filename); - exit(EXIT_FAILURE); - } - - return fp; -} - -size_t rzip_get_infsize(uint8_t *src) -{ - if (src[0] != 0x11 || src[1] != 0x73) { - fprintf(stderr, "rzip_get_infsize: 1173 not found\n"); - exit(EXIT_FAILURE); - } - - return src[2] << 16 | (src[3] << 8) | src[4]; -} - -int rzip_inflate(uint8_t *dst, size_t dstlen, uint8_t *src, size_t srclen) -{ - if (src[0] != 0x11 || src[1] != 0x73) { - fprintf(stderr, "rzip_inflate: 1173 not found\n"); - - for (int i = 0; i < 16; i++) { - fprintf(stderr, "%02x ", src[i]); - } - - fprintf(stderr, "\n"); - - exit(EXIT_FAILURE); - } - - z_stream stream; - stream.zalloc = Z_NULL; - stream.zfree = Z_NULL; - stream.opaque = Z_NULL; - stream.avail_in = srclen - 5; - stream.next_in = &src[5]; - stream.avail_out = dstlen; - stream.next_out = dst; - - inflateInit2(&stream, -15); - int ret = inflate(&stream, Z_FINISH); - inflateEnd(&stream); - - return ret; -} - -int rzip_deflate(uint8_t *dst, size_t *dstlen, uint8_t *src, size_t srclen) -{ - dst[0] = 0x11; - dst[1] = 0x73; - dst[2] = (srclen >> 16) & 0xff; - dst[3] = (srclen >> 8) & 0xff; - dst[4] = srclen & 0xff; - - *dstlen = *dstlen - 5; - - z_stream stream; - stream.zalloc = Z_NULL; - stream.zfree = Z_NULL; - stream.opaque = Z_NULL; - stream.avail_in = srclen; - stream.next_in = src; - stream.avail_out = *dstlen; - stream.next_out = &dst[5]; - - deflateInit2(&stream, 9, Z_DEFLATED, -15, 9, Z_DEFAULT_STRATEGY); - int ret = deflate(&stream, Z_FINISH); - deflateEnd(&stream); - - *dstlen = stream.next_out - dst; - - return ret; -} diff --git a/port/src/romdata.c b/port/src/romdata.c index 6c3b57973..b17c6f54b 100644 --- a/port/src/romdata.c +++ b/port/src/romdata.c @@ -545,3 +545,19 @@ u32 romdataSegGetSize(const char *segName) { return romdataGetSeg(segName)->size; } + +u32 romdataGetEstimatedFileSize(u32 size, FileType filetype) +{ + switch (filetype) { + case FT_BG: return (u32)(size * 1.1); + case FT_TILES: return (u32)(size * 1.1); + case FT_LANG: return (u32)(size * 1.3); + case FT_SETUP: return (u32)(size * 3.3); + case FT_PADS: return (u32)(size * 1.7); + case FT_MODEL: return (u32)(size * 1.7); + default: + sysLogPrintf(LOG_WARNING, "wrong file type in romdataGetEstimatedFileSize: %d", filetype); + return size; + } +} + diff --git a/src/game/bg.c b/src/game/bg.c index 71ff53d24..af6ca5300 100644 --- a/src/game/bg.c +++ b/src/game/bg.c @@ -1509,6 +1509,11 @@ void bgReset(s32 stagenum) primcompsize = *(u32 *)&header[8]; var8007fc54 = inflatedsize - primcompsize; var8007fc54 -= 0xc; + +#ifdef PLATFORM_64BIT + inflatedsize = romdataGetEstimatedFileSize(inflatedsize, FT_BG); +#endif + inflatedsize = ALIGN16(inflatedsize); // Allocate space for the primary bg data @@ -1529,7 +1534,7 @@ void bgReset(s32 stagenum) bgInflate((u8 *) scratch, g_BgPrimaryData, primcompsize); #ifndef PLATFORM_N64 - preprocessBgSection1(g_BgPrimaryData, 0x0f000000); + preprocessBgSection1(g_BgPrimaryData, inflatedsize, 0x0f000000); #endif // Shrink the allocation (ie. free the scratch space) @@ -1998,7 +2003,8 @@ void bgBuildTables(s32 stagenum) numlightsptr++; } -#ifndef PLATFORM_N64 +// in x64, lights are already pre-processed at this point (TEMP) +#if !defined(PLATFORM_N64) && !defined(PLATFORM_64BIT) preprocessBgLights(g_BgLightsFileData, 0); #endif @@ -2820,6 +2826,11 @@ void bgLoadRoom(s32 roomnum) #endif } +#ifdef PLATFORM_64BIT + alloclen = alloclen * 4; // just to be safe for now, adjust properly later #TODO +#endif + + #ifdef PLATFORM_N64 bgGarbageCollectRooms(alloclen, false); @@ -2856,7 +2867,7 @@ void bgLoadRoom(s32 roomnum) // Inflate the data to the left side of the allocation inflatedlen = bgInflate(memaddr, allocation, g_BgRooms[roomnum + 1].unk00 - g_BgRooms[roomnum].unk00); #ifndef PLATFORM_N64 - preprocessBgRoom(allocation, g_BgRooms[roomnum].unk00); + inflatedlen = preprocessBgRoom(allocation, inflatedlen, g_BgRooms[roomnum].unk00); #endif g_Rooms[roomnum].gfxdata = (struct roomgfxdata *)allocation; diff --git a/src/game/bondgun.c b/src/game/bondgun.c index 54e8989cf..7ab6fb13e 100644 --- a/src/game/bondgun.c +++ b/src/game/bondgun.c @@ -3831,7 +3831,7 @@ void bgunTickGunLoad(void) *player->gunctrl.loadmemptr = ptr; *player->gunctrl.loadmemremaining = remaining; - loadsize = ALIGN64(fileGetInflatedSize(player->gunctrl.loadfilenum)) + 0x8000; + loadsize = ALIGN64(fileGetInflatedSize(player->gunctrl.loadfilenum, FT_MODEL)) + 0x8000; osSyncPrintf("BriGun: Loading - %s, pMem 0x%08x Size %d\n"); @@ -3933,7 +3933,7 @@ void bgunTickGunLoad(void) modeldef0f1a7560(modeldef, player->gunctrl.loadfilenum, 0x05000000, modeldef, &player->gunctrl.texpool, false); - fileGetInflatedSize(player->gunctrl.loadfilenum); + fileGetInflatedSize(player->gunctrl.loadfilenum, FT_MODEL); fileGetLoadedSize(player->gunctrl.loadfilenum); fileGetLoadedSize(player->gunctrl.loadfilenum); fileGetLoadedSize(player->gunctrl.loadfilenum); @@ -3946,7 +3946,7 @@ void bgunTickGunLoad(void) newvalue = ALIGN64(texGetPoolLeftPos(&player->gunctrl.texpool)); remaining = *player->gunctrl.loadmemremaining; - remaining -= (s32)(newvalue - *player->gunctrl.loadmemptr); + remaining -= (intptr_t)(newvalue - *player->gunctrl.loadmemptr); *player->gunctrl.loadmemptr = newvalue; *player->gunctrl.loadmemremaining = remaining; diff --git a/src/game/file.c b/src/game/file.c index dce879590..35cec4df3 100644 --- a/src/game/file.c +++ b/src/game/file.c @@ -11,7 +11,7 @@ #include "data.h" #include "types.h" #ifndef PLATFORM_N64 -#include "romdata.h" +#include "system.h" #endif /** @@ -4176,7 +4176,7 @@ void fileLoad(u8 *dst, u32 allocationlen, romptr_t *romaddrptr, struct fileinfo dmaExec(dst, *romaddrptr, romsize); } else { // DMA the compressed data to scratch space then inflate - u8 *scratch = (dst + allocationlen) - ((romsize + 7) & 0xfffffffffffffff8); + u8 *scratch = (dst + allocationlen) - ((romsize + 7) & (uintptr_t)~7); if ((uintptr_t)scratch - (uintptr_t)dst < 8) { info->loadedsize = 0; @@ -4255,7 +4255,7 @@ void fileLoadPartToAddr(u16 filenum, void *memaddr, s32 offset, u32 len) } } -u32 fileGetInflatedSize(s32 filenum) +u32 fileGetInflatedSize(s32 filenum, FileType filetype) { u8 *ptr; u8 buffer[0x50]; @@ -4283,7 +4283,11 @@ u32 fileGetInflatedSize(s32 filenum) } if (rzipIs1173(ptr)) { +#ifdef PLATFORM_N64 return (ptr[2] << 16) | (ptr[3] << 8) | ptr[4]; +#else + return romdataGetEstimatedFileSize((ptr[2] << 16) | (ptr[3] << 8) | ptr[4], filetype); +#endif } #if VERSION < VERSION_NTSC_1_0 @@ -4300,7 +4304,7 @@ u32 fileGetInflatedSize(s32 filenum) return 0; } -void *fileLoadToNew(s32 filenum, u32 method) +void *fileLoadToNew(s32 filenum, u32 method, FileType filetype) { struct fileinfo *info = &g_FileInfo[filenum]; u32 stack; @@ -4308,7 +4312,7 @@ void *fileLoadToNew(s32 filenum, u32 method) if (method == FILELOADMETHOD_EXTRAMEM || method == FILELOADMETHOD_DEFAULT) { if (info->loadedsize == 0) { - info->loadedsize = (fileGetInflatedSize(filenum) + 0x20) & 0xfffffff0; + info->loadedsize = (fileGetInflatedSize(filenum, filetype) + 0x20) & 0xfffffff0; if (method == FILELOADMETHOD_EXTRAMEM) { info->loadedsize += 0x8000; diff --git a/src/game/lang.c b/src/game/lang.c index a1e672d9f..cd6ffc8c2 100644 --- a/src/game/lang.c +++ b/src/game/lang.c @@ -382,6 +382,7 @@ void langLoad(s32 bank) if ((uintptr_t)g_LangBuffer + len + g_LangBufferSize - (uintptr_t)g_LangBufferPos >= 0) { s32 len2 = (uintptr_t)g_LangBuffer + g_LangBufferSize - (uintptr_t)g_LangBufferPos; len2 = len2 / 32 * 32; + g_LoadType = LOADTYPE_LANG; g_LangBanks[bank] = fileLoadToAddr(langGetFileId(bank), FILELOADMETHOD_DEFAULT, (u8 *)g_LangBufferPos, len2); g_LangBufferPos = (u8 *)(align32((uintptr_t)g_LangBufferPos + len)); } else { @@ -389,13 +390,15 @@ void langLoad(s32 bank) } #else s32 file_id = langGetFileId(bank); - g_LangBanks[bank] = fileLoadToNew(file_id, FILELOADMETHOD_DEFAULT); + g_LoadType = LOADTYPE_LANG; + g_LangBanks[bank] = fileLoadToNew(file_id, FILELOADMETHOD_DEFAULT, FT_LANG); #endif } void langLoadToAddr(s32 bank, u8 *dst, s32 size) { s32 file_id = langGetFileId(bank); + g_LoadType = LOADTYPE_LANG; g_LangBanks[bank] = fileLoadToAddr(file_id, FILELOADMETHOD_DEFAULT, dst, size); } @@ -418,12 +421,15 @@ char *langGet(s32 textid) { s32 bankindex = textid >> 9; s32 textindex = textid & 0x1ff; - uintptr_t *bank = g_LangBanks[bankindex]; + uintptr_t *bank = (uintptr_t*)g_LangBanks[bankindex]; uintptr_t addr; if (bank && bank[textindex]) { -// addr = (uintptr_t)bank + PD_BE32(bank[textindex]); - addr = (u8*)bank + (bank[textindex]); +#ifdef PLATFORM_64BIT + addr = (uintptr_t)bank + bank[textindex]; +#else + addr = (uintptr_t)bank + PD_BE32(bank[textindex]); +#endif } else { addr = 0; } diff --git a/src/game/langreset.c b/src/game/langreset.c index 71bbd0cfc..0f64e8cec 100644 --- a/src/game/langreset.c +++ b/src/game/langreset.c @@ -51,15 +51,27 @@ void langReset(s32 stagenum) langReload(); #else // Versions prior to PAL load the language directly - g_LangBanks[LANGBANK_GUN] = fileLoadToNew(langGetFileId(LANGBANK_GUN), FILELOADMETHOD_DEFAULT); - g_LangBanks[LANGBANK_MPMENU] = fileLoadToNew(langGetFileId(LANGBANK_MPMENU), FILELOADMETHOD_DEFAULT); - g_LangBanks[LANGBANK_PROPOBJ] = fileLoadToNew(langGetFileId(LANGBANK_PROPOBJ), FILELOADMETHOD_DEFAULT); - g_LangBanks[LANGBANK_MPWEAPONS] = fileLoadToNew(langGetFileId(LANGBANK_MPWEAPONS), FILELOADMETHOD_DEFAULT); - g_LangBanks[LANGBANK_OPTIONS] = fileLoadToNew(langGetFileId(LANGBANK_OPTIONS), FILELOADMETHOD_DEFAULT); - g_LangBanks[LANGBANK_MISC] = fileLoadToNew(langGetFileId(LANGBANK_MISC), FILELOADMETHOD_DEFAULT); + g_LoadType = LOADTYPE_LANG; // find be a better way to do this.. + g_LangBanks[LANGBANK_GUN] = fileLoadToNew(langGetFileId(LANGBANK_GUN), FILELOADMETHOD_DEFAULT, FT_LANG); + + g_LoadType = LOADTYPE_LANG; + g_LangBanks[LANGBANK_MPMENU] = fileLoadToNew(langGetFileId(LANGBANK_MPMENU), FILELOADMETHOD_DEFAULT, FT_LANG); + + g_LoadType = LOADTYPE_LANG; + g_LangBanks[LANGBANK_PROPOBJ] = fileLoadToNew(langGetFileId(LANGBANK_PROPOBJ), FILELOADMETHOD_DEFAULT, FT_LANG); + + g_LoadType = LOADTYPE_LANG; + g_LangBanks[LANGBANK_MPWEAPONS] = fileLoadToNew(langGetFileId(LANGBANK_MPWEAPONS), FILELOADMETHOD_DEFAULT, FT_LANG); + + g_LoadType = LOADTYPE_LANG; + g_LangBanks[LANGBANK_OPTIONS] = fileLoadToNew(langGetFileId(LANGBANK_OPTIONS), FILELOADMETHOD_DEFAULT, FT_LANG); + + g_LoadType = LOADTYPE_LANG; + g_LangBanks[LANGBANK_MISC] = fileLoadToNew(langGetFileId(LANGBANK_MISC), FILELOADMETHOD_DEFAULT, FT_LANG); if (stagenum == STAGE_CREDITS) { - g_LangBanks[LANGBANK_TITLE] = fileLoadToNew(langGetFileId(LANGBANK_TITLE), FILELOADMETHOD_DEFAULT); + g_LoadType = LOADTYPE_LANG; + g_LangBanks[LANGBANK_TITLE] = fileLoadToNew(langGetFileId(LANGBANK_TITLE), FILELOADMETHOD_DEFAULT, FT_LANG); } #endif } diff --git a/src/game/menu.c b/src/game/menu.c index 2f3441964..2b0b73d99 100644 --- a/src/game/menu.c +++ b/src/game/menu.c @@ -1869,7 +1869,7 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) bodyfilenum = g_HeadsAndBodies[bodynum].filenum; - totalfilelen = fileGetInflatedSize(bodyfilenum); + totalfilelen = fileGetInflatedSize(bodyfilenum, FT_MODEL); totalfilelen = ALIGN64(totalfilelen); if (g_HeadsAndBodies[bodynum].unk00_01) { @@ -1877,7 +1877,7 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) headfilenum = 0xffff; } else { headfilenum = g_HeadsAndBodies[headnum].filenum; - totalfilelen += ALIGN64(fileGetInflatedSize(headfilenum)); + totalfilelen += ALIGN64(fileGetInflatedSize(headfilenum, FT_MODEL)); } #ifdef PLATFORM_64BIT @@ -1915,7 +1915,7 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) body0f02ce8c(bodynum, headnum, menumodel->bodymodeldef, menumodel->headmodeldef, totalfilelen * 0, &menumodel->bodymodel, false, 1); } else { - totalfilelen = ALIGN64(fileGetInflatedSize(menumodel->newparams)) + 0x4000; + totalfilelen = ALIGN64(fileGetInflatedSize(menumodel->newparams, FT_MODEL)) + 0x4000; if (1); texInitPool(&texpool, &menumodel->allocstart[(u32)totalfilelen], menumodel->alloclen - totalfilelen); diff --git a/src/game/modeldef.c b/src/game/modeldef.c index ccd473c69..ef2d13023 100644 --- a/src/game/modeldef.c +++ b/src/game/modeldef.c @@ -190,7 +190,7 @@ struct modeldef *modeldefLoad(u16 fileid, u8 *dst, s32 size, struct texpool *arg if (dst) { modeldef = fileLoadToAddr(fileid, FILELOADMETHOD_EXTRAMEM, dst, size); } else { - modeldef = fileLoadToNew(fileid, FILELOADMETHOD_EXTRAMEM, FT_LANG); + modeldef = fileLoadToNew(fileid, FILELOADMETHOD_EXTRAMEM, FT_MODEL); } modelPromoteTypeToPointer(modeldef); diff --git a/src/game/player.c b/src/game/player.c index 2b3b418c3..9dfed6656 100644 --- a/src/game/player.c +++ b/src/game/player.c @@ -1424,14 +1424,14 @@ void playerTickChrBody(void) offset1 += sizeof(struct weaponobj); offset1 = ALIGN64(offset1); - offset2 = offset1 + ALIGN64(fileGetInflatedSize(g_HeadsAndBodies[bodynum].filenum)); + offset2 = offset1 + ALIGN64(fileGetInflatedSize(g_HeadsAndBodies[bodynum].filenum, FT_MODEL)); if (headnum >= 0) { - offset2 += ALIGN64(fileGetInflatedSize(g_HeadsAndBodies[headnum].filenum)); + offset2 += ALIGN64(fileGetInflatedSize(g_HeadsAndBodies[headnum].filenum, FT_MODEL)); } if (weaponmodelnum >= 0) { - offset2 += ALIGN64(fileGetInflatedSize(g_ModelStates[weaponmodelnum].fileid)); + offset2 += ALIGN64(fileGetInflatedSize(g_ModelStates[weaponmodelnum].fileid, FT_MODEL)); } offset2 += 0x4000; diff --git a/src/game/setup.c b/src/game/setup.c index 627bf1420..491ca501f 100644 --- a/src/game/setup.c +++ b/src/game/setup.c @@ -1319,7 +1319,7 @@ void setupLoadFiles(s32 stagenum) g_LoadType = LOADTYPE_SETUP; - g_GeCreditsData = (u8 *)fileLoadToNew(filenum, FILELOADMETHOD_DEFAULT); + g_GeCreditsData = (u8 *)fileLoadToNew(filenum, FILELOADMETHOD_DEFAULT, FT_SETUP); setup = (struct stagesetup *)g_GeCreditsData; langLoad(langGetLangBankIndexFromStagenum(stagenum)); @@ -1330,7 +1330,7 @@ void setupLoadFiles(s32 stagenum) g_LoadType = LOADTYPE_PADS; - g_StageSetup.padfiledata = fileLoadToNew(g_Stages[g_StageIndex].padsfileid, FILELOADMETHOD_DEFAULT); + g_StageSetup.padfiledata = fileLoadToNew(g_Stages[g_StageIndex].padsfileid, FILELOADMETHOD_DEFAULT, FT_PADS); g_StageSetup.waypoints = NULL; g_StageSetup.waygroups = NULL; diff --git a/src/game/tilesreset.c b/src/game/tilesreset.c index ed074c028..c87400ed0 100644 --- a/src/game/tilesreset.c +++ b/src/game/tilesreset.c @@ -18,7 +18,7 @@ void tilesReset(void) } g_LoadType = LOADTYPE_TILES; - g_TileFileData.u8 = fileLoadToNew(g_Stages[index].tilefileid, FILELOADMETHOD_DEFAULT); + g_TileFileData.u8 = fileLoadToNew(g_Stages[index].tilefileid, FILELOADMETHOD_DEFAULT, FT_TILES); g_TileNumRooms = *g_TileFileData.u32; g_TileRooms = g_TileFileData.u32 + 1; diff --git a/src/include/game/file.h b/src/include/game/file.h index d26f6ca61..22908feb9 100644 --- a/src/include/game/file.h +++ b/src/include/game/file.h @@ -4,12 +4,16 @@ #include "data.h" #include "types.h" +#ifndef PLATFORM_N64 +#include "romdata.h" +#endif + romptr_t fileGetRomAddress(s32 filenum); s32 fileGetRomSize(s32 filenum); void filesInit(void); void fileLoadPartToAddr(u16 filenum, void *memaddr, s32 offset, u32 len); -u32 fileGetInflatedSize(s32 filenum); -void *fileLoadToNew(s32 filenum, u32 method); +u32 fileGetInflatedSize(s32 filenum, FileType filetype); +void *fileLoadToNew(s32 filenum, u32 method, FileType filetype); void *fileLoadToAddr(s32 filenum, s32 method, u8 *ptr, u32 size); u32 fileGetLoadedSize(s32 filenum); u32 fileGetAllocationSize(s32 filenum); From 06a45738cc548430ad2defe1cd36df6325bf6cad Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 17:33:53 +0800 Subject: [PATCH 17/81] portx64: preprocess header left behind --- port/include/preprocess.h | 40 ++++++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 17 deletions(-) diff --git a/port/include/preprocess.h b/port/include/preprocess.h index 5d930dcd5..12c6d9da1 100644 --- a/port/include/preprocess.h +++ b/port/include/preprocess.h @@ -3,32 +3,38 @@ #include -typedef void (*preprocessfunc)(u8 *data, u32 size); +typedef u8* (*preprocessfunc)(u8 *data, u32 size, u32 *outSize); -void preprocessAnimations(u8 *data, u32 size); -void preprocessMpConfigs(u8 *data, u32 size); -void preprocessFont(u8 *data, u32 size); -void preprocessJpnFont(u8 *data, u32 size); -void preprocessALBankFile(u8 *data, u32 size); +u8* preprocessAnimations(u8 *data, u32 size, u32 *outSize); +u8* preprocessMpConfigs(u8 *data, u32 size, u32 *outSize); +u8* preprocessFont(u8 *data, u32 size, u32 *outSize); +u8* preprocessJpnFont(u8 *data, u32 size, u32 *outSize); +u8* preprocessALBankFile(u8 *data, u32 size, u32 *outSize); void preprocessALCMidiHdr(u8 *data, u32 size); -void preprocessSequences(u8 *data, u32 size); -void preprocessFiringRange(u8 *data, u32 size); -void preprocessTexturesList(u8 *data, u32 size); +u8* preprocessSequences(u8 *data, u32 size, u32 *outSize); +u8* preprocessTexturesList(u8 *data, u32 size, u32 *outSize); void preprocessBgSection1Header(u8 *data, u32 size); -void preprocessBgSection1(u8 *data, u32 size); void preprocessBgSection2Header(u8 *data, u32 size); void preprocessBgSection2(u8 *data, u32 size); void preprocessBgSection3Header(u8 *data, u32 size); void preprocessBgSection3(u8 *data, u32 size); -void preprocessBgRoom(u8 *data, u32 ofs); void preprocessBgLights(u8 *data, u32 ofs); -void preprocessLangFile(u8 *data, u32 size); -void preprocessPadsFile(u8 *data, u32 size); -void preprocessTilesFile(u8 *data, u32 size); -void preprocessSetupFile(u8 *data, u32 size); -void preprocessModelFile(u8 *data, u32 size); -void preprocessGunFile(u8 *data, u32 size); +u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize); +u8 *preprocessPadsFile(u8 *data, u32 size, u32 *outSize); +u8 *preprocessTilesFile(u8 *data, u32 size, u32 *outSize); +u8 *preprocessSetupFile(u8 *data, u32 size, u32 *outSize); +u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize); +u8 *preprocessGunFile(u8 *data, u32 size, u32 *outSize); + +// these are in pdextract +u8 *preprocessFont_x64(u8*, u32, u32*); +u8 *preprocessALBankFile_x64(u8*, u32, u32*); +u8 *preprocessModelFile_x64(u8*, u32, u32*); +u8 *preprocessTilesFile_x64(u8*, u32, u32*); +u8 *preprocessSetupFile_x64(u8*, u32, u32*); +u8 *preprocessPadsFile_x64(u8*, u32, u32*); +u8 *preprocessLangFile_x64(u8*, u32, u32*); #endif From 71dc521baa878b18d705fd5e88af05ba878e4c57 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 17:36:49 +0800 Subject: [PATCH 18/81] portx64: menu bug fix: code intermingling handlerdata_dropdown and handlerdata_list values --- src/game/menuitem.c | 4 ++-- src/include/types.h | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/game/menuitem.c b/src/game/menuitem.c index df2216b42..ea0732a10 100644 --- a/src/game/menuitem.c +++ b/src/game/menuitem.c @@ -576,7 +576,7 @@ Gfx *menuitemListRender(Gfx *gdl, struct menurendercontext *context) spb8.type19.gdl = gdl; spb8.type19.unk04 = optionindex; - spb8.type19.renderdata2 = (void *)((uintptr_t)&renderdata & 0xffffffff); + spb8.type19.renderdata2 = (void *)((uintptr_t)&renderdata); spb8.type19.unk0c = sp15c.list.unk04; gdl = (Gfx *) context->item->handler(MENUOP_RENDER, context->item, &spb8); @@ -1884,7 +1884,7 @@ Gfx *menuitemModelRender(Gfx *gdl, struct menurendercontext *context) renderdata.unk10 = true; data.type19.gdl = gdl; - data.type19.unk04 = (uintptr_t)&renderdata; + data.type19.unk04 = (intptr_t)&renderdata; data.type19.renderdata2 = &renderdata; gdl = (Gfx *)context->item->handler(MENUOP_RENDER, context->item, &data); diff --git a/src/include/types.h b/src/include/types.h index a2e66417f..3b761854c 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -3348,8 +3348,8 @@ struct handlerdata_checkbox { }; struct handlerdata_dropdown { - u32 value; - u32 unk04; + uintptr_t value; + uintptr_t unk04; }; struct handlerdata_keyboard { @@ -3390,8 +3390,8 @@ struct menuitemrenderdata { struct handlerdata_type19 { Gfx *gdl; union { - s32 unk04; - u32 unk04u32; + intptr_t unk04; + uintptr_t unk04u32; }; struct menuitemrenderdata *renderdata2; s32 unk0c; From 50b912db98a82c7fdf2877195c64de2fdd185cd8 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 17:37:33 +0800 Subject: [PATCH 19/81] portx64: bug fix: weatherResetRooms accessing invalid memory when returning to STAGE_TITLE --- src/game/weatherreset.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/game/weatherreset.c b/src/game/weatherreset.c index 5c7c1683b..6ea5efc58 100644 --- a/src/game/weatherreset.c +++ b/src/game/weatherreset.c @@ -82,7 +82,9 @@ void weatherReset(void) #else g_WeatherData->windspeed = g_CurWeatherConfig->windspeed; // set up the weatherproof flags in all rooms - weatherResetRooms(); + if (g_Vars.stagenum != STAGE_TITLE) { + weatherResetRooms(); + } #endif g_WeatherData->audiohandles[0] = 0; From 288a007202ea66195fc1317b146bcfc37cc8dae4 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 17:43:05 +0800 Subject: [PATCH 20/81] portx64: bug fix: mp3 code accessing out of bounds memory: increased alloc/audio heap size --- src/lib/mp3.c | 4 ++++ src/lib/snd.c | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/lib/mp3.c b/src/lib/mp3.c index 9f69e9ac5..e94af6431 100644 --- a/src/lib/mp3.c +++ b/src/lib/mp3.c @@ -60,7 +60,11 @@ void mp3Init(ALHeap *heap) var8009c6d8 = alHeapAlloc(heap, 256 * sizeof(var8009c6d8[0]), 1); var8009c6dc = alHeapAlloc(heap, 256 * sizeof(var8009c6dc[0]), 1); +#ifdef PLATFORM_64BIT + var8009c640 = alHeapAlloc(heap, 2*10500 * sizeof(struct mp3decfourbytes), 1); +#else var8009c640 = alHeapAlloc(heap, 10500 * sizeof(struct mp3decfourbytes), 1); +#endif var8009c644 = alHeapAlloc(heap, 8192 * sizeof(var8009c644[0]), 1); mp3mainInit(); diff --git a/src/lib/snd.c b/src/lib/snd.c index 6beac208b..c2c88d694 100644 --- a/src/lib/snd.c +++ b/src/lib/snd.c @@ -1460,7 +1460,7 @@ void sndInit(void) #endif #ifdef PLATFORM_64BIT - heaplen = 1024 * 661; + heaplen = 1024 * 745; #endif g_Vars.langfilteron = false; From 89397bd5660832831d35deea071407ddc0b13eb1 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 17:46:50 +0800 Subject: [PATCH 21/81] portx64: makefile: added PLATFORM_64BIT define --- Makefile.port | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Makefile.port b/Makefile.port index 4c451c939..8b3ecfd00 100644 --- a/Makefile.port +++ b/Makefile.port @@ -139,6 +139,10 @@ ifeq ($(DEBUG),1) DEFINES := $(DEFINES) DEBUG=1 endif +ifeq (1,$(TARGET_64BIT)) + DEFINES += PLATFORM_64BIT=1 +endif + C_DEFINES := $(foreach d,$(DEFINES),-D$(d)) A_DIR := src/assets/$(ROMID) From 5beef0916be6b4c04faa465f83558824fb7c167f Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 17:47:35 +0800 Subject: [PATCH 22/81] portx64: warn if memory pool is full --- src/lib/memp.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/lib/memp.c b/src/lib/memp.c index 99b8bf476..6c59b91c5 100644 --- a/src/lib/memp.c +++ b/src/lib/memp.c @@ -6,6 +6,7 @@ #include "lib/memp.h" #include "data.h" #include "types.h" +#include "system.h" /** * memp - memory pool allocation system. @@ -178,10 +179,12 @@ void *mempAllocFromBank(struct memorypool *pool, u32 size, u8 poolnum) } if (pool->leftpos > pool->rightpos) { + sysLogPrintf(LOG_NOTE, "#warning: memory pool %x is full. Req: %d\n", pool, size); return 0; } if (pool->leftpos + size > pool->rightpos) { + sysLogPrintf(LOG_NOTE, "#warning: memory pool %x is full. Req: %d\n", pool, size); return 0; } From 949faf09d91e75ad47d12c2d1aca6fbea3a9cc2e Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 17:49:44 +0800 Subject: [PATCH 23/81] portx64: undo disable sound --- port/src/main.c | 1 - 1 file changed, 1 deletion(-) diff --git a/port/src/main.c b/port/src/main.c index fcf6923bb..e31e090a2 100644 --- a/port/src/main.c +++ b/port/src/main.c @@ -130,7 +130,6 @@ int main(int argc, const char **argv) sysLogPrintf(LOG_NOTE, "rom file at %p - %p", g_RomFile, g_RomFile + g_RomFileSize); g_SndDisabled = sysArgCheck("--no-sound"); - g_SndDisabled = true; g_StageNum = sysArgGetInt("--boot-stage", STAGE_TITLE); From 844d6c7ec8b6f417eee02daccf192ab0b5b2a26a Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sun, 4 Aug 2024 18:19:41 +0800 Subject: [PATCH 24/81] portx64: pd-extract setups: a few bug fixes and changed how lists are copied --- port/pdextract/ext_setups.c | 156 ++++++++++++------------------------ 1 file changed, 52 insertions(+), 104 deletions(-) diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c index 345523990..80d78c9f9 100644 --- a/port/pdextract/ext_setups.c +++ b/port/pdextract/ext_setups.c @@ -655,7 +655,7 @@ u32 convert_props(u8* dst, u8* src) conv_default_obj(&dstobj->base, cmd); - dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -678,7 +678,7 @@ u32 convert_props(u8* dst, u8* src) conv_default_obj(&dstobj->base, cmd); - dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->rotoryrot, srcobj->rotoryrot); @@ -898,7 +898,7 @@ u32 convert_props(u8* dst, u8* src) conv_default_obj(&dstobj->base, cmd); - dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -939,7 +939,7 @@ u32 convert_props(u8* dst, u8* src) conv_default_obj(&dstobj->base, cmd); - dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -1002,14 +1002,13 @@ u32 convert_props(u8* dst, u8* src) } *(u32*)(dst) = htobe32(OBJTYPE_END); - dst += sizeof(int); + dst += sizeof(u32); return (u32)(dst - start); } static uintptr_t convert_intro(u8 *dst, u8 *src) { - u8* start = dst; u8 cmd_size[] = { 3, // INTROCMD_SPAWN 4, // INTROCMD_WEAPON @@ -1023,7 +1022,7 @@ static uintptr_t convert_intro(u8 *dst, u8 *src) 3, // INTROCMD_CASE 3, // INTROCMD_CASERESPAWN 2, // INTROCMD_HILL - 1, // INTROCMD_END + 1, // the INTROCMD_END constant itself }; s32* dstintro = (s32*)dst; @@ -1042,13 +1041,11 @@ static uintptr_t convert_intro(u8 *dst, u8 *src) if (cmd == INTROCMD_END) break; } - return (u32)((u8*)dstintro - start); + return (u32)((u8*)dstintro - dst); } -static uintptr_t convert_paths(u8 *dst, u8 *src) +static u32 convert_paths(u8 *dst, u8 *src) { - u8* start = dst; - struct n64_path* srcpath = (struct n64_path*)src; struct path* dstpath = (struct path*)dst; @@ -1058,21 +1055,20 @@ static uintptr_t convert_paths(u8 *dst, u8 *src) PD_CONV_VAL(dstpath->flags, srcpath->flags); PD_CONV_VAL(dstpath->len, srcpath->len); - dstpath++; - if (srcpath->ptr_pads == 0) break; - srcpath ++; + dstpath++; + srcpath++; } - return (u32)((u8*)dstpath - start); + // extra pointer for the end marker + return (u32)((u8*)dstpath - dst + sizeof(uintptr_t)); } -static int convert_pads(struct path *dstpaths, u8 *dst, u8 *src, uintptr_t dstpos) +static u32 convert_pads(struct path *dstpaths, u8 *dst, u8 *src, u32 dstpos) { - uintptr_t start = dstpos; - s32* dstpads = (s32*)&dst[dstpos]; - s32 i = 0; + u32 start = dstpos; + s32 *dstpads = (s32*)&dst[dstpos]; while (dstpaths->pads) { s32 *pads = (s32*)&src[(uintptr_t)dstpaths->pads]; dstpaths->pads = (s32*)dstpos; @@ -1087,70 +1083,65 @@ static int convert_pads(struct path *dstpaths, u8 *dst, u8 *src, uintptr_t dstpo dstpaths++; } - dstpaths->pads = 0; return dstpos - start; } -static uintptr_t convert_ailists(u8* dst, u8* src) +static u32 convert_ailists(u8* dst, u8* src) { - u8* start = dst; - struct n64_ailist* srcailist = (struct n64_ailist*)src; - struct ailist* dstailist = (struct path*)dst; + struct ailist* dstailist = (struct ailist*)dst; while (true) { // at this point these fields are already converted, so we just assign dstailist->list = srcailist->ptr_list; dstailist->id = srcailist->id; - dstailist++; if (srcailist->ptr_list == 0) break; + dstailist++; srcailist++; } - return (u32)((u8*)dstailist - start); + return (u32)((u8*)dstailist - dst + sizeof(uintptr_t)); } -static int convert_lists(uintptr_t ofs_ailists, u8 *dst, u8 *src, uintptr_t dstpos) +u32 chraiGetAilistLength(u8 *list); + +static u32 convert_lists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) { - struct n64_ailist* ailists = (struct n64_ailist*)&src[ofs_ailists]; + reset_markers(); + struct n64_ailist *src_ailists = (struct n64_ailist*)&src[src_ofs]; // count the lists and pre-convert the fields int nlists = 0; - for (struct n64_ailist* tmp = ailists; tmp->ptr_list; tmp++, nlists++) { + for (struct n64_ailist *tmp = src_ailists; tmp->ptr_list; tmp++, nlists++) { tmp->ptr_list = srctodst32(tmp->ptr_list); tmp->id = srctodst32(tmp->id); } - // sort ailists by the list addr - for (int i = 0; i < nlists; i++) { - uintptr_t minidx = i; + for (struct n64_ailist *ailist = src_ailists; ailist->ptr_list; ailist++) { + // update the src list pointers here + uintptr_t src_ptr_list = (uintptr_t) ailist->ptr_list; + ailist->ptr_list = (u8*)dstpos; - for (int j = i + 1; j < nlists; j++) - if (ailists[j].ptr_list < ailists[minidx].ptr_list) minidx = j; - - struct n64_ailist tmp = ailists[i]; - ailists[i] = ailists[minidx]; - ailists[minidx] = tmp; - } - - for (int i = 0; i < nlists; i++) { - u8* start = (u8*)&src[(uintptr_t)ailists[i].ptr_list]; - u8* end = (i == nlists - 1) ? &src[ofs_ailists] : &src[(uintptr_t)ailists[i + 1].ptr_list]; - - size_t size = end - start; - - // update the src list pointers as we go - ailists[i].ptr_list = (u8*)dstpos; - - if (size > 0) - memcpy(dst + dstpos, start, size); - - dstpos += size; + // multiple ailists can point to the same list, so we need to check if it was already copied + struct ptrmarker *marker = find_marker(src_ptr_list); + if (marker) { + ailist->ptr_list = marker->ptr_host; + continue; + } + add_marker(src_ptr_list, dstpos); + + u8 *list = &src[src_ptr_list]; + u32 listsize = chraiGetAilistLength(list); + memcpy(dst + dstpos, list, listsize); + + // align to the next multiple of 4 + dstpos += ((listsize + 3) >> 2) << 2; } + return dstpos; } @@ -1172,68 +1163,25 @@ static int convert_setup(u8 *dst, u8 *src, u32 srclen) dstpos += convert_props(&dst[dstpos], &src[srcpos]); srcpos = src_header->ptr_intro; - dst_header->intro = (u32*) dstpos; + dst_header->intro = (s32*)dstpos; dstpos += convert_intro(&dst[dstpos], &src[srcpos]); + + // write the lists bytecodes before the ailists entries + dstpos = convert_lists(dst, src, dstpos, src_header->ptr_ailists); + + srcpos = src_header->ptr_ailists; + dst_header->ailists = (struct ailist*)dstpos; + dstpos += convert_ailists(&dst[dstpos], &src[srcpos]); srcpos = src_header->ptr_paths; dst_header->paths = (struct path*) dstpos; dstpos += convert_paths(&dst[dstpos], &src[srcpos]); - // write the lists bytecodes before the ailists entries - dstpos += convert_lists(src_header->ptr_ailists, dst, src, dstpos); - - srcpos = src_header->ptr_ailists; - dst_header->ailists = (struct ailist*) dstpos; - dstpos += convert_ailists(&dst[dstpos], &src[srcpos]); - dstpos += convert_pads(&dst[(uintptr_t)dst_header->paths], dst, src, dstpos); return dstpos; } - -void test_conv_functions() -{ - f32 dst0; - f32 src0 = 3.141592; - PD_CONV_VAL(dst0, src0); - - u32 dst1; - u32 src1 = 0xaabbccdd; - PD_CONV_VAL(dst1, src1); - - s32 dst2; - s32 src2 = 0xaabbccdd; - PD_CONV_VAL(dst2, src2); - - u16 dst3; - u16 src3 = 0xaabb; - PD_CONV_VAL(dst3, src3); - - s16 dst4; - s16 src4 = 0xaabb; - PD_CONV_VAL(dst4, src4); - - struct coord dst5; - struct n64_coord src5 = { 1.0f, 2.0f, 3.0f }; - PD_CONV_VAL(dst5, src5); - - s32* dst6; - s32* src6 = (s32*)0xcafebaca; - PD_CONV_PTR(dst6, src6); - - s32 dst7[3]; - s32 src7[3] = { 0xaabbccdd, 0x11223344, 0xddbbccaa }; - PD_CONV_ARRAY(dst7, src7); - - s32 dst8[2][2]; - s32 src8[2][2] = { - { 0xaabbccdd, 0x11223344 }, - { 0xffeeddcc, 0x55667788 } - }; - PD_CONV_ARRAY2D(dst8, src8); -} - u8 *preprocessSetupFile_x64(u8 *data, u32 size, u32 *outSize) { u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_SETUP); u8 *dst = sysMemZeroAlloc(newSizeEstimated); From 373f08ca3e045d3940dd94cf32a5aa847c70e421 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sun, 4 Aug 2024 18:26:09 +0800 Subject: [PATCH 25/81] portx64: pd-extract setups: a few bug fixes and changed how lists are copied - moved ptrmarkers out of ext_file_bg to common - function to get ailist length --- port/pdextract/common.c | 33 +++++++++++++++++++++++++++++++++ port/pdextract/common.h | 9 +++++++++ port/pdextract/ext_file_bg.c | 36 ------------------------------------ src/game/chrai.c | 16 ++++++++++++++++ 4 files changed, 58 insertions(+), 36 deletions(-) create mode 100644 port/pdextract/common.c diff --git a/port/pdextract/common.c b/port/pdextract/common.c new file mode 100644 index 000000000..dcf425574 --- /dev/null +++ b/port/pdextract/common.c @@ -0,0 +1,33 @@ +#include "common.h" +#include "system.h" + +struct ptrmarker m_PtrMarkers[2048]; +int m_NumPtrMarkers; + +void add_marker(u32 ptr_src, uintptr_t ptr_host) +{ + if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { + sysLogPrintf(LOG_ERROR, "[BG] Marker limit exceeded"); + exit(EXIT_FAILURE); + } + + m_PtrMarkers[m_NumPtrMarkers].ptr_src = ptr_src; + m_PtrMarkers[m_NumPtrMarkers].ptr_host = ptr_host; + m_NumPtrMarkers++; +} + +struct ptrmarker* find_marker(uintptr_t ptr_src) +{ + for (int i = 0; i < m_NumPtrMarkers; i++) { + if (m_PtrMarkers[i].ptr_src == ptr_src) { + return &m_PtrMarkers[i]; + } + } + + return NULL; +} + +void reset_markers() +{ + m_NumPtrMarkers = 0; +} diff --git a/port/pdextract/common.h b/port/pdextract/common.h index 665bd6d48..84ee4e08a 100644 --- a/port/pdextract/common.h +++ b/port/pdextract/common.h @@ -77,4 +77,13 @@ void gbi_convert_vtx(uint8_t* dst, uint32_t dstpos, int count); void gbi_gdl_rewrite_addrs(uint8_t* dst, uint32_t offset); void gbi_add_tex_addr(uint32_t src_offset, uint32_t dst_offset); +struct ptrmarker { + u32 ptr_src; + uintptr_t ptr_host; +}; + +void add_marker(u32 ptr_src, uintptr_t ptr_host); +struct ptrmarker* find_marker(uintptr_t ptr_src); +void reset_markers(); + #endif diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c index 69a445356..c45ca1cb0 100644 --- a/port/pdextract/ext_file_bg.c +++ b/port/pdextract/ext_file_bg.c @@ -6,44 +6,8 @@ #include "system.h" #include "platform.h" -struct ptrmarker { - u32 ptr_src; - uintptr_t ptr_host; -}; - - -struct ptrmarker m_PtrMarkers[2048]; -int m_NumPtrMarkers; int m_SizeGDLs; -static void add_marker(u32 ptr_src, uintptr_t ptr_host) -{ - if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { - sysLogPrintf(LOG_ERROR, "[BG] Marker limit exceeded"); - exit(EXIT_FAILURE); - } - - m_PtrMarkers[m_NumPtrMarkers].ptr_src = ptr_src; - m_PtrMarkers[m_NumPtrMarkers].ptr_host = ptr_host; - m_NumPtrMarkers++; -} - -static struct ptrmarker* find_marker(uintptr_t ptr_src) -{ - for (int i = 0; i < m_NumPtrMarkers; i++) { - if (m_PtrMarkers[i].ptr_src == ptr_src) { - return &m_PtrMarkers[i]; - } - } - - return NULL; -} - -static void reset_markers() -{ - m_NumPtrMarkers = 0; -} - /** * 4 bytes decompressed size of primary data * 4 bytes compressed size of section 1 in its entirety diff --git a/src/game/chrai.c b/src/game/chrai.c index ea5294dc0..1dfaefb71 100644 --- a/src/game/chrai.c +++ b/src/game/chrai.c @@ -814,3 +814,19 @@ u32 chraiGetCommandLength(u8 *ailist, u32 aioffset) return 1; } + +// used by ext_setup +u32 chraiGetAilistLength(u8* list) +{ + if (!list) return 0; + + u8* cmd = list; + + while (true) { + u8 type = cmd[1]; + cmd += chraiGetCommandLength(cmd, 0); + if (type == AICMD_END) break; + } + + return (u32)(cmd - list); +} From e8006f3446bf447331d7b6f8a001e1786b3677b0 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sun, 4 Aug 2024 18:34:04 +0800 Subject: [PATCH 26/81] portx64: pd-extract util gbi: fixed gdl conversion so it works on x86 it works but is still a bit messy, may rewrite it later --- port/pdextract/util_gbi.c | 40 ++++++++++++++++++++++++--------------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/port/pdextract/util_gbi.c b/port/pdextract/util_gbi.c index e41080aea..d89aac769 100644 --- a/port/pdextract/util_gbi.c +++ b/port/pdextract/util_gbi.c @@ -2,6 +2,7 @@ #include #include #include "common.h" +#include "gbi.h" #ifdef FORCE_BE32 #define HOST_DWORDS_PER_CMD 1 @@ -117,7 +118,7 @@ void gbi_convert_vtx(u8 *dst, u32 offset, int count) * Segment 5 is the start of the model file. The data in these files shifts * depending on the pointer size, so this function adjusts the offset accordingly. */ -static uint64_t gbi_rewrite_addr(uint64_t cmd, u8 opcode) +static u64 gbi_rewrite_addr(u64 cmd, u8 opcode) { u8 segment = (cmd & 0x0f000000) >> 24; u32 offset = cmd & 0x00ffffff; @@ -143,34 +144,42 @@ void gbi_gdl_rewrite_addrs(u8 *dst, u32 offset) { if (!offset) return; - uint64_t *cmds = (uint64_t*)(dst + (offset & 0x00ffffff)); + u64 *cmds = (u64 *)(dst + (offset & 0x00ffffff)); if (!cmds) return; - uint64_t cmd; + u64 cmd; do { cmd = *cmds; + Gfx* gfxcmd = cmds; + int idx = 0; + u8 opcode = (cmd >> 24) & 0xff; - if (CMD_HAS_ADDR((cmd << 32))) { - u8 opcode = (cmd >> 24) & 0xff; - cmds[1] = gbi_rewrite_addr(cmds[1], opcode); +#if HOST_DWORDS_PER_CMD == 2 + idx = 1; + opcode = (cmd >> 24) & 0xff; +#endif + cmd = (u64)opcode << 56; + + if (CMD_HAS_ADDR(cmd)) { + cmds[idx] = gbi_rewrite_addr(cmds[idx], opcode); } - if (CMD_IS_SEGMENTED((cmd << 32))) { - cmds[1] |= 1; + if (CMD_IS_SEGMENTED(cmd)) { + gfxcmd->words.w1 |= 1; } - cmds += 2; - } while (!CMD_IS_ENDDL((cmd << 32))); + cmds += HOST_DWORDS_PER_CMD; + } while (!CMD_IS_ENDDL(cmd)); } u32 gbi_convert_gdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds) { dstpos = ALIGN8(dstpos); - uint64_t *n64_cmd = (uint64_t*)&src[srcpos]; - uint64_t *host_cmd = (uint64_t*)&dst[dstpos]; - uint64_t cmd; + u64 *n64_cmd = (u64*)&src[srcpos]; + u64 *host_cmd = (u64*)&dst[dstpos]; + u64 cmd; do { cmd = srctoh64(*n64_cmd); @@ -183,10 +192,11 @@ u32 gbi_convert_gdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds) host_cmd[1] |= 1; } #else - host_cmd[0] = htodst64(cmd); + host_cmd[0] = (cmd >> 32) | ((cmd & 0xffffffff) << 32); if (segment_cmds && CMD_IS_SEGMENTED(cmd)) { - host_cmd[0] |= 1; + Gfx* gfxcmd = (Gfx*)host_cmd; + gfxcmd->words.w1 |= 1; } #endif From 40273bdba148069963be2717d0a53e89f3bf872c Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sun, 4 Aug 2024 18:37:01 +0800 Subject: [PATCH 27/81] portx64: romdata: check for PLATFORM_64BIT inside romdataGetEstimatedFileSize() --- port/src/romdata.c | 4 +++- src/game/file.c | 4 ---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/port/src/romdata.c b/port/src/romdata.c index b17c6f54b..92cda2416 100644 --- a/port/src/romdata.c +++ b/port/src/romdata.c @@ -548,6 +548,7 @@ u32 romdataSegGetSize(const char *segName) u32 romdataGetEstimatedFileSize(u32 size, FileType filetype) { +#ifdef PLATFORM_64BIT switch (filetype) { case FT_BG: return (u32)(size * 1.1); case FT_TILES: return (u32)(size * 1.1); @@ -557,7 +558,8 @@ u32 romdataGetEstimatedFileSize(u32 size, FileType filetype) case FT_MODEL: return (u32)(size * 1.7); default: sysLogPrintf(LOG_WARNING, "wrong file type in romdataGetEstimatedFileSize: %d", filetype); - return size; } +#endif + return size; } diff --git a/src/game/file.c b/src/game/file.c index 35cec4df3..79ebd40ce 100644 --- a/src/game/file.c +++ b/src/game/file.c @@ -4283,11 +4283,7 @@ u32 fileGetInflatedSize(s32 filenum, FileType filetype) } if (rzipIs1173(ptr)) { -#ifdef PLATFORM_N64 - return (ptr[2] << 16) | (ptr[3] << 8) | ptr[4]; -#else return romdataGetEstimatedFileSize((ptr[2] << 16) | (ptr[3] << 8) | ptr[4], filetype); -#endif } #if VERSION < VERSION_NTSC_1_0 From e36df05a4fca57f443c6461635f49d4ec1c62d11 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sun, 4 Aug 2024 22:29:13 +0800 Subject: [PATCH 28/81] portx64: pd-extract: renamed fin_marker --- port/pdextract/common.c | 2 +- port/pdextract/common.h | 2 +- port/pdextract/ext_file_bg.c | 2 +- port/pdextract/ext_setups.c | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/port/pdextract/common.c b/port/pdextract/common.c index dcf425574..6b1244c62 100644 --- a/port/pdextract/common.c +++ b/port/pdextract/common.c @@ -16,7 +16,7 @@ void add_marker(u32 ptr_src, uintptr_t ptr_host) m_NumPtrMarkers++; } -struct ptrmarker* find_marker(uintptr_t ptr_src) +struct ptrmarker* find_ptr_marker(uintptr_t ptr_src) { for (int i = 0; i < m_NumPtrMarkers; i++) { if (m_PtrMarkers[i].ptr_src == ptr_src) { diff --git a/port/pdextract/common.h b/port/pdextract/common.h index 84ee4e08a..df7ca062a 100644 --- a/port/pdextract/common.h +++ b/port/pdextract/common.h @@ -83,7 +83,7 @@ struct ptrmarker { }; void add_marker(u32 ptr_src, uintptr_t ptr_host); -struct ptrmarker* find_marker(uintptr_t ptr_src); +struct ptrmarker* find_ptr_marker(uintptr_t ptr_src); void reset_markers(); #endif diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c index c45ca1cb0..3d617ad97 100644 --- a/port/pdextract/ext_file_bg.c +++ b/port/pdextract/ext_file_bg.c @@ -302,7 +302,7 @@ void relink_ptr(uintptr_t** ptr) { if (!*ptr) return; - struct ptrmarker* marker = find_marker(*ptr); + struct ptrmarker* marker = find_ptr_marker(*ptr); if (!marker) { fprintf(stderr, "[BG] WARNING: Unable to relink pointer: %p\n", ptr); exit(EXIT_FAILURE); diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c index 80d78c9f9..e39453b43 100644 --- a/port/pdextract/ext_setups.c +++ b/port/pdextract/ext_setups.c @@ -1126,7 +1126,7 @@ static u32 convert_lists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) ailist->ptr_list = (u8*)dstpos; // multiple ailists can point to the same list, so we need to check if it was already copied - struct ptrmarker *marker = find_marker(src_ptr_list); + struct ptrmarker *marker = find_ptr_marker(src_ptr_list); if (marker) { ailist->ptr_list = marker->ptr_host; continue; From 3573906eef60a7c0ce2b797a7bfbbf81de087527 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Sun, 4 Aug 2024 22:30:49 +0800 Subject: [PATCH 29/81] portx64: pd-extract setup: fixed doorscale obj --- port/pdextract/ext_setups.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c index e39453b43..4dbf7afe2 100644 --- a/port/pdextract/ext_setups.c +++ b/port/pdextract/ext_setups.c @@ -254,7 +254,7 @@ u32 convert_props(u8* dst, u8* src) struct n64_doorscaleobj* srcobj = (struct n64_doorscaleobj*)cmd; struct doorscaleobj* dstobj = (struct doorscaleobj*)dst; - dstobj->unk00 = htobe32(srcobj->unk00); + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->scale, srcobj->scale); dst += sizeof(struct doorscaleobj); From c1c71ea21d4be3e13962ce79e006beffa9c6f5bf Mon Sep 17 00:00:00 2001 From: Raf <> Date: Thu, 8 Aug 2024 04:01:11 +0800 Subject: [PATCH 30/81] portx64: pd-extract models: tons of fixes: data alignments, stargunfire, preprocess textures --- port/pdextract/ext_file_model.c | 168 +++++++++++++++++++++++--------- 1 file changed, 120 insertions(+), 48 deletions(-) diff --git a/port/pdextract/ext_file_model.c b/port/pdextract/ext_file_model.c index efef151f5..d9bb5c889 100644 --- a/port/pdextract/ext_file_model.c +++ b/port/pdextract/ext_file_model.c @@ -2,6 +2,10 @@ #include #include +#include "types.h" +#include "gbi.h" +#include "game/texdecompress.h" + #include "common.h" #include "romdata.h" #include "system.h" @@ -28,6 +32,7 @@ enum contenttype { /*18*/ CT_RODATA_HEADSPOT, /*19*/ CT_RODATA_DL, /*20*/ CT_RODATA_19, + /*21*/ CT_VTXCOL4, // CT_VTXCOL but aligned to 4 bytes instead of 8 }; struct marker { @@ -46,51 +51,30 @@ struct alignconfig m_AlignConfigs[] = { /* 0*/ { 16, 4 }, /* 1*/ { 4, 4 }, /* 2*/ { 4, 4 }, - /* 3*/ { 8, 8 }, + /* 3*/ { 8, 8 }, // CT_TEXDATA /* 4*/ { 4, 4 }, - /* 5*/ { 8, 8 }, - /* 6*/ { 8, 8 }, + /* 5*/ { 8, 4 }, // CT_VTXCOL + /* 6*/ { 8, 8 }, // CT_GDL /* 7*/ { 4, 4 }, /* 8*/ { 4, 4 }, - /* 9*/ { 8, 4 }, - /*10*/ { 4, 8 }, + /* 9*/ { 8, 4 }, // CT_GUNDL + /*10*/ { 4, 4 }, /*11*/ { 4, 4 }, /*12*/ { 4, 4 }, /*13*/ { 4, 4 }, /*14*/ { 4, 4 }, /*15*/ { 4, 4 }, /*16*/ { 4, 4 }, - /*17*/ { 8, 8 }, + /*17*/ { 8, 4 }, // CT_STARGUNFIRE /*18*/ { 4, 4 }, - /*19*/ { 8, 8 }, + /*19*/ { 8, 4 }, // CT_RODATA_DL /*20*/ { 4, 4 }, + /*21*/ { 4, 4 }, }; struct marker m_Markers[1024]; int m_NumMarkers; -#define MODELNODETYPE_CHRINFO 0x01 -#define MODELNODETYPE_POSITION 0x02 -#define MODELNODETYPE_GUNDL 0x04 -#define MODELNODETYPE_05 0x05 -#define MODELNODETYPE_DISTANCE 0x08 -#define MODELNODETYPE_REORDER 0x09 -#define MODELNODETYPE_BBOX 0x0a -#define MODELNODETYPE_0B 0x0b -#define MODELNODETYPE_CHRGUNFIRE 0x0c -#define MODELNODETYPE_0D 0x0d -#define MODELNODETYPE_0E 0x0e -#define MODELNODETYPE_0F 0x0f -#define MODELNODETYPE_11 0x11 -#define MODELNODETYPE_TOGGLE 0x12 -#define MODELNODETYPE_POSITIONHELD 0x15 -#define MODELNODETYPE_STARGUNFIRE 0x16 -#define MODELNODETYPE_HEADSPOT 0x17 -#define MODELNODETYPE_DL 0x18 -#define MODELNODETYPE_19 0x19 -#define MODELNODETYPE_0100 0x0100 -#define MODELNODETYPE_0200 0x0200 - struct src_modeldef { u32 ptr_rootnode; u32 ptr_skel; @@ -230,7 +214,9 @@ struct src_rodata_type11 { u32 unk08; u32 unk0c; u32 unk10; - u32 ptr_unk14; + u32 ptr_unk14; // not used + u32 extra1; + u32 extra2; }; struct dst_rodata_type11 { @@ -239,7 +225,9 @@ struct dst_rodata_type11 { u32 unk08; u32 unk0c; u32 unk10; - uintptr_t ptr_unk14; + u32 unk14; + u32 extra1; + u32 extra2; }; struct src_rodata_toggle { @@ -327,6 +315,18 @@ struct dst_texconfig { u8 unk0b; }; +#define PD_PTR_BASE(x, b) (void *)((u8 *)b + (uintptr_t)x) +#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (uintptr_t)x) + + +static inline void *minPtr(void *a, void *b) { + return (a && (a < b || !b)) ? a : b; +} + +static inline void *minPtr3(void *a, void *b, void *c) { + return minPtr(minPtr(a, b), c); +} + static struct marker *find_marker(u32 src_offset) { for (int i = 0; i < m_NumMarkers; i++) { @@ -444,14 +444,9 @@ static void populate_markers(u8 *src) break; case CT_RODATA_GUNDL: struct src_rodata_gundl *src_gundl = src_thing; - numvtx = srctoh16(src_gundl->numvertices); - colstart = srctoh32(src_gundl->ptr_vertices) + numvtx * 12; - colstart = ALIGN(colstart, m_AlignConfigs[marker->type].before); - set_marker(srctoh32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); set_marker(srctoh32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); set_marker(srctoh32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); - set_marker(colstart, CT_VTXCOL, marker->src_offset); break; case CT_RODATA_DISTANCE: struct src_rodata_distance *src_dist = src_thing; @@ -472,18 +467,16 @@ static void populate_markers(u8 *src) break; case CT_RODATA_STARGUNFIRE: struct src_rodata_stargunfire *src_stargunfire = src_thing; - numvtx = srctoh16(src_stargunfire->unk00); + colstart = srctoh32(src_stargunfire->unk00)*4*12; + u32 vtxstart = srctoh32(src_stargunfire->ptr_vertices); + colstart = ALIGN(vtxstart + colstart, 8); - set_marker(srctoh32(src_stargunfire->ptr_vertices), CT_VTXCOL, marker->src_offset); - set_marker(srctoh32(src_stargunfire->ptr_vertices) + numvtx * 12, CT_VTXCOL, marker->src_offset); + set_marker(srctoh32(src_stargunfire->ptr_vertices), CT_VTXCOL4, marker->src_offset); + set_marker(colstart, CT_VTXCOL4, marker->src_offset); set_marker(srctoh32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); break; case CT_RODATA_DL: struct src_rodata_dl *src_dl = src_thing; - numvtx = srctoh16(src_dl->numvertices); - colstart = srctoh32(src_dl->ptr_vertices) + numvtx * 12; - colstart = ALIGN(colstart, 8); - set_marker(srctoh32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); set_marker(srctoh32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); set_marker(srctoh32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); @@ -601,6 +594,7 @@ static u32 convert_content(u8 *dst, u8 *src, u32 src_file_len) } break; case CT_VTXCOL: + case CT_VTXCOL4: memcpy(dst_thing, src_thing, src_len); dstpos += src_len; break; @@ -713,7 +707,8 @@ static u32 convert_content(u8 *dst, u8 *src, u32 src_file_len) dst_type11->unk08 = srctodst32(src_type11->unk08); dst_type11->unk0c = srctodst32(src_type11->unk0c); dst_type11->unk10 = srctodst32(src_type11->unk10); - dst_type11->ptr_unk14 = srctodst32(src_type11->ptr_unk14); // Not read by game engine + dst_type11->extra1 = srctodst32(src_type11->extra1); + dst_type11->extra2 = srctodst32(src_type11->extra2); dstpos += sizeof(*dst_type11); break; case CT_RODATA_TOGGLE: @@ -788,12 +783,16 @@ static u32 resolve_pointer(u32 src_offset) return marker ? (0x05000000 | marker->dst_offset) : 0; } -static void relink_pointers(u8 *dst, u8 *src) +static u8 *relink_pointers(u8 *dst, u8 *src) { + u8 *textures_end = 0; + for (int i = 0; i < m_NumMarkers; i++) { struct marker *marker = &m_Markers[i]; void *src_thing = &src[marker->src_offset]; void *dst_thing = &dst[marker->dst_offset]; + + u8 *lowestptr = 0; switch (marker->type) { case CT_MODELDEF: @@ -811,6 +810,8 @@ static void relink_pointers(u8 *dst, u8 *src) dst_node->ptr_next = htodst32(resolve_pointer(srctoh32(src_node->ptr_next))); dst_node->ptr_prev = htodst32(resolve_pointer(srctoh32(src_node->ptr_prev))); dst_node->ptr_child = htodst32(resolve_pointer(srctoh32(src_node->ptr_child))); + + lowestptr = dst_node->ptr_rodata; break; case CT_TEXCONFIG: struct src_texconfig *src_texconfig = src_thing; @@ -851,6 +852,8 @@ static void relink_pointers(u8 *dst, u8 *src) if (dst_gundl->ptr_opagdl) dst_gundl->ptr_opagdl |= 1; if (dst_gundl->ptr_xlugdl) dst_gundl->ptr_xlugdl |= 1; + + lowestptr = minPtr3(dst_gundl->ptr_opagdl, dst_gundl->ptr_xlugdl, dst_gundl->ptr_vertices); break; case CT_RODATA_DISTANCE: struct src_rodata_distance *src_dist = src_thing; @@ -882,12 +885,14 @@ static void relink_pointers(u8 *dst, u8 *src) dst_stargunfire->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_stargunfire->ptr_vertices))); dst_stargunfire->ptr_gdl = htodst32(resolve_pointer(srctoh32(src_stargunfire->ptr_gdl))); - gbi_convert_vtx(dst, dst_stargunfire->ptr_vertices & 0x00ffffff, dst_stargunfire->unk00); + gbi_convert_vtx(dst, dst_stargunfire->ptr_vertices & 0x00ffffff, dst_stargunfire->unk00*4); gbi_set_vtx(srctoh32(src_stargunfire->ptr_vertices), dst_stargunfire->ptr_vertices); gbi_set_segment(0x04, dst_stargunfire->ptr_vertices); gbi_gdl_rewrite_addrs(dst, dst_stargunfire->ptr_gdl); if (dst_stargunfire->ptr_gdl) dst_stargunfire->ptr_gdl |= 1; + + lowestptr = minPtr(dst_stargunfire->ptr_gdl, dst_stargunfire->ptr_vertices); break; case CT_RODATA_DL: struct src_rodata_dl *src_dl = src_thing; @@ -906,6 +911,9 @@ static void relink_pointers(u8 *dst, u8 *src) if (dst_dl->ptr_opagdl) dst_dl->ptr_opagdl |= 1; if (dst_dl->ptr_xlugdl) dst_dl->ptr_xlugdl |= 1; + + lowestptr = minPtr3(dst_dl->ptr_opagdl, dst_dl->ptr_xlugdl, dst_dl->ptr_colours); + lowestptr = minPtr(lowestptr, dst_dl->ptr_vertices); break; case CT_TEXDATA: case CT_VTXCOL: @@ -917,7 +925,11 @@ static void relink_pointers(u8 *dst, u8 *src) case CT_RODATA_19: break; } + + textures_end = minPtr(textures_end, lowestptr); } + + return textures_end; } static int convert_model(u8 *dst, u8 *src, u32 srclen) @@ -928,12 +940,47 @@ static int convert_model(u8 *dst, u8 *src, u32 srclen) sort_markers(); dstpos = convert_content(dst, src, srclen); - relink_pointers(dst, src); + u8 *tex_end = relink_pointers(dst, src); + preprocess_textures(dst, tex_end); return dstpos; } -u8 *preprocessModelFile_x64(u8 *data, u32 size, u32 *outSize) +void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) +{ + for (uint32_t i = 0; i < size_bytes; i += 4, ++dest) { + *dest = PD_BE32(*dest); + } +} + +void preprocess_textures(u8 *base, u8 *textures_end) +{ + struct modeldef* mdl = (struct modeldef*)base; + if (!mdl->texconfigs) return; + + u32 ofs = 0x5000000; + struct textureconfig* texconfigs = PD_PTR_BASEOFS(mdl->texconfigs, base, ofs); + for (s16 i = 0; i < mdl->numtexconfigs; ++i) { + if ((texconfigs[i].texturenum & 0xf000000) == 0x5000000) { + // embedded texture; we need to unswizzle this + u8* texdata = PD_PTR_BASEOFS(texconfigs[i].textureptr, base, ofs); + // figure out the max possible size the texture can have, because sometimes the texconfig is wrong + const u32 maxSize = (textures_end > texconfigs[i].textureptr) ? (textures_end - texconfigs[i].textureptr) : 0; + // figure out the format and unswizzle + const s32 format = texConfigToFormat(&texconfigs[i]); + texSwizzleInternal(texdata, texconfigs[i].width, texconfigs[i].height, format, maxSize); + + if (format == TEXFORMAT_RGBA32) { + // for some reason, RGBA32 embedded textures don't need to be byte-swapped, + // so we byte-swap them here, which will be undone when the renderer imports it + u32 size_bytes = texconfigs[i].width * texconfigs[i].height * 4; + preprocessTextureRGBA32Embedded((u32*)texdata, size_bytes); + } + } + } +} + +u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize) { gbi_reset(); @@ -942,6 +989,28 @@ u8 *preprocessModelFile_x64(u8 *data, u32 size, u32 *outSize) u32 newSize = convert_model(dst, data, size); + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); + + *outSize = newSize; + + return 0; +} + +u8 *preprocessGunFile(u8 *data, u32 size, u32 *outSize) +{ + gbi_reset(); + + u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_MODEL); + u8 *dst = sysMemZeroAlloc(newSizeEstimated+128); + + u32 newSize = convert_model(dst, data, size); + if (newSize > newSizeEstimated) { sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); exit(EXIT_FAILURE); @@ -954,3 +1023,6 @@ u8 *preprocessModelFile_x64(u8 *data, u32 size, u32 *outSize) return 0; } + +#undef PD_PTR_BASE +#undef PD_PTR_BASEOFS From 9e34f80a2ce6ab8f839d70b5c772d9b7fc3e8bb2 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Thu, 8 Aug 2024 04:13:08 +0800 Subject: [PATCH 31/81] portx64: pd-extract audio: check for repeated pointers before converting --- port/pdextract/common.c | 4 ++-- port/pdextract/common.h | 20 +++++++++++------- port/pdextract/ext_audio.c | 43 ++++++++++++++++++++------------------ 3 files changed, 37 insertions(+), 30 deletions(-) diff --git a/port/pdextract/common.c b/port/pdextract/common.c index 6b1244c62..3a9f5190f 100644 --- a/port/pdextract/common.c +++ b/port/pdextract/common.c @@ -1,13 +1,13 @@ #include "common.h" #include "system.h" -struct ptrmarker m_PtrMarkers[2048]; +struct ptrmarker m_PtrMarkers[1024*8]; int m_NumPtrMarkers; void add_marker(u32 ptr_src, uintptr_t ptr_host) { if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { - sysLogPrintf(LOG_ERROR, "[BG] Marker limit exceeded"); + sysLogPrintf(LOG_ERROR, "Marker limit exceeded"); exit(EXIT_FAILURE); } diff --git a/port/pdextract/common.h b/port/pdextract/common.h index df7ca062a..4d0141f32 100644 --- a/port/pdextract/common.h +++ b/port/pdextract/common.h @@ -66,17 +66,21 @@ #define srctodst64(value) htodst64(srctoh64(value)) #ifdef FORCE_BE32 -#define uintptr_t uint32_t +#define uintptr_t u32 #endif -void gbi_reset(void); -void gbi_set_segment(int segment, uint32_t offset); -void gbi_set_vtx(uint32_t src_offset, uint32_t dst_offset); -uint32_t gbi_convert_gdl(uint8_t *dst, uint32_t dstpos, uint8_t *src, uint32_t srcpos, int segment_cmds); -void gbi_convert_vtx(uint8_t* dst, uint32_t dstpos, int count); -void gbi_gdl_rewrite_addrs(uint8_t* dst, uint32_t offset); -void gbi_add_tex_addr(uint32_t src_offset, uint32_t dst_offset); +#define ALIGN(val, size) ((val + (size - 1)) & ~(size - 1)) +// gbi related functions +void gbi_reset(void); +void gbi_set_segment(int segment, u32 offset); +void gbi_set_vtx(u32 src_offset, u32 dst_offset); +u32 gbi_convert_gdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds); +void gbi_convert_vtx(u8* dst, u32 dstpos, int count); +void gbi_gdl_rewrite_addrs(u8* dst, u32 offset); +void gbi_add_tex_addr(u32 src_offset, u32 dst_offset); + +// ptr marker functions struct ptrmarker { u32 ptr_src; uintptr_t ptr_host; diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c index a4992f1b8..c64130cf4 100644 --- a/port/pdextract/ext_audio.c +++ b/port/pdextract/ext_audio.c @@ -170,6 +170,17 @@ struct host_bankfile { uintptr_t bankArray[1]; // ptr to struct host_bank }; +// only proceeds to convert the next item if it's not already converted +#define AL_NEXT_ITEM(field, func) { \ + struct ptrmarker *marker = find_ptr_marker(srcpos); \ + if (marker == NULL) { \ + field = htodst32(dstpos); \ + add_marker(srcpos, field); \ + dstpos = func(dst, dstpos, src, srcpos); \ + } else { \ + field = marker->ptr_host; } \ +} + static int convert_audio_envelope(u8 *dst, int dstpos, u8 *src, int srcpos) { struct generic_envelope *n64_envelope = (struct generic_envelope *) &src[srcpos]; @@ -266,25 +277,22 @@ static int convert_audio_wavetable(u8 *dst, int dstpos, u8 *src, int srcpos) if (host_wavetable->type == AL_ADPCM_WAVE) { if (n64_wavetable->waveInfo.adpcmWave.loop) { - host_wavetable->waveInfo.adpcmWave.loop = htodst32(dstpos); srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.loop); - dstpos = convert_audio_adpcm_loop(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.loop, convert_audio_adpcm_loop); } else { host_wavetable->waveInfo.adpcmWave.loop = 0; } if (n64_wavetable->waveInfo.adpcmWave.book) { - host_wavetable->waveInfo.adpcmWave.book = htodst32(dstpos); srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.book); - dstpos = convert_audio_adpcm_book(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.book, convert_audio_adpcm_book); } else { host_wavetable->waveInfo.adpcmWave.book = 0; } } else if (host_wavetable->type == AL_RAW16_WAVE) { if (n64_wavetable->waveInfo.rawWave.loop) { - host_wavetable->waveInfo.rawWave.loop = htodst32(dstpos); srcpos = srctoh32(n64_wavetable->waveInfo.rawWave.loop); - dstpos = convert_audio_raw_loop(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_wavetable->waveInfo.rawWave.loop, convert_audio_raw_loop); } else { host_wavetable->waveInfo.rawWave.loop = 0; } @@ -301,25 +309,22 @@ static int convert_audio_sound(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos += sizeof(struct host_sound); if (n64_sound->envelope) { - host_sound->envelope = htodst32(dstpos); srcpos = srctoh32(n64_sound->envelope); - dstpos = convert_audio_envelope(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_sound->envelope, convert_audio_envelope); } else { host_sound->envelope = 0; } if (n64_sound->keyMap) { - host_sound->keyMap = htodst32(dstpos); srcpos = srctoh32(n64_sound->keyMap); - dstpos = convert_audio_keymap(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_sound->keyMap, convert_audio_keymap); } else { host_sound->keyMap = 0; } if (n64_sound->wavetable) { - host_sound->wavetable = htodst32(dstpos); srcpos = srctoh32(n64_sound->wavetable); - dstpos = convert_audio_wavetable(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_sound->wavetable, convert_audio_wavetable); } else { host_sound->wavetable = 0; } @@ -355,9 +360,8 @@ static int convert_audio_instrument(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos = dstpos + sizeof(struct host_instrument) + sizeof(uintptr_t) * (soundCount - 1); for (int i = 0; i < soundCount; i++) { - host_instrument->soundArray[i] = htodst32(dstpos); srcpos = srctoh32(n64_instrument->soundArray[i]); - dstpos = convert_audio_sound(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_instrument->soundArray[i], convert_audio_sound); } return dstpos; @@ -377,17 +381,15 @@ static int convert_audio_bank(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos = dstpos + sizeof(struct host_bank) + sizeof(uintptr_t) * (instCount - 1); if (n64_bank->percussion) { - host_bank->percussion = htodst32(dstpos); srcpos = srctoh32(n64_bank->percussion); - dstpos = convert_audio_instrument(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_bank->percussion, convert_audio_instrument); } else { host_bank->percussion = 0; } for (int i = 0; i < instCount; i++) { - host_bank->instArray[i] = htodst32(dstpos); srcpos = srctoh32(n64_bank->instArray[i]); - dstpos = convert_audio_instrument(dst, dstpos, src, srcpos); + AL_NEXT_ITEM(host_bank->instArray[i], convert_audio_instrument); } return dstpos; @@ -416,8 +418,9 @@ static int convert_audio_bankfile(u8 *dst, u8 *src) u8 *preprocessALBankFile_x64(u8 *src, u32 size, u32 *outSize) { - u32 dstlen = size * 4; - u8* dst = sysMemZeroAlloc(dstlen); + reset_markers(); + u32 dstlen = size * 3; + u8 *dst = sysMemZeroAlloc(dstlen); *outSize = convert_audio_bankfile(dst, src); *outSize = ALIGN16(*outSize); From 8b1e81f32a71d5f778fd64a2267bdf4003d9d7c7 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Thu, 8 Aug 2024 17:15:33 +0800 Subject: [PATCH 32/81] portx64: pd-extract,preprocess: renamed "_x64" functions, removed now unused preprocess functions, increased snd heap size (x86) --- .gitignore | 1 + port/include/preprocess.h | 9 - port/pdextract/ext_audio.c | 2 +- port/pdextract/ext_file_bg.c | 2 - port/pdextract/ext_file_lang.c | 2 +- port/pdextract/ext_file_pads.c | 2 +- port/pdextract/ext_file_tiles.c | 2 +- port/pdextract/ext_fonts.c | 2 +- port/pdextract/ext_setups.c | 2 +- port/src/preprocess.c | 1303 +------------------------------ port/src/romdata.c | 37 +- src/game/bg.c | 5 - src/game/lang.c | 4 - src/include/constants.h | 1 - src/lib/snd.c | 8 +- 15 files changed, 27 insertions(+), 1355 deletions(-) diff --git a/.gitignore b/.gitignore index 4aaf2032f..040d48862 100644 --- a/.gitignore +++ b/.gitignore @@ -22,3 +22,4 @@ src/assets/*/textures/*.bin src/generated tools/mkrom/mkrom /.vs +CppProperties.json diff --git a/port/include/preprocess.h b/port/include/preprocess.h index 12c6d9da1..c8734c1cd 100644 --- a/port/include/preprocess.h +++ b/port/include/preprocess.h @@ -28,13 +28,4 @@ u8 *preprocessSetupFile(u8 *data, u32 size, u32 *outSize); u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize); u8 *preprocessGunFile(u8 *data, u32 size, u32 *outSize); -// these are in pdextract -u8 *preprocessFont_x64(u8*, u32, u32*); -u8 *preprocessALBankFile_x64(u8*, u32, u32*); -u8 *preprocessModelFile_x64(u8*, u32, u32*); -u8 *preprocessTilesFile_x64(u8*, u32, u32*); -u8 *preprocessSetupFile_x64(u8*, u32, u32*); -u8 *preprocessPadsFile_x64(u8*, u32, u32*); -u8 *preprocessLangFile_x64(u8*, u32, u32*); - #endif diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c index c64130cf4..f42de4725 100644 --- a/port/pdextract/ext_audio.c +++ b/port/pdextract/ext_audio.c @@ -416,7 +416,7 @@ static int convert_audio_bankfile(u8 *dst, u8 *src) return dstpos; } -u8 *preprocessALBankFile_x64(u8 *src, u32 size, u32 *outSize) +u8 *preprocessALBankFile(u8 *src, u32 size, u32 *outSize) { reset_markers(); u32 dstlen = size * 3; diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c index 3d617ad97..dc3d57243 100644 --- a/port/pdextract/ext_file_bg.c +++ b/port/pdextract/ext_file_bg.c @@ -564,7 +564,6 @@ static void convert_section3_lightcounts(u8 *dst, u32 *dstpos, u8 *src, u32 *src *dstpos += (m_NumRooms - 1); } -#ifdef PLATFORM_64BIT void preprocessBgSection1(u8 *data, u32 size, u32 ofs) { u8 *dst = sysMemZeroAlloc(size); @@ -596,4 +595,3 @@ u32 preprocessBgRoom(u8 *data, u32 size, u32 room_ofs) return newSize; } -#endif \ No newline at end of file diff --git a/port/pdextract/ext_file_lang.c b/port/pdextract/ext_file_lang.c index b9cd46409..fe518053c 100644 --- a/port/pdextract/ext_file_lang.c +++ b/port/pdextract/ext_file_lang.c @@ -75,7 +75,7 @@ u32 convert_lang_file(u8 *dst, u8 *src, size_t srclen) return ALIGN16(cur_dst_offset); } -u8 *preprocessLangFile_x64(u8 *data, u32 size, u32 *outSize) { +u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize) { u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_LANG); u8 *dst = sysMemZeroAlloc(newSizeEstimated); diff --git a/port/pdextract/ext_file_pads.c b/port/pdextract/ext_file_pads.c index d9aae0fc4..ef7632e1c 100644 --- a/port/pdextract/ext_file_pads.c +++ b/port/pdextract/ext_file_pads.c @@ -310,7 +310,7 @@ static int convert_pads_file(u8 *dst, u8 *src) return dstpos; } -u8* preprocessPadsFile_x64(u8 *data, u32 size, u32 *outSize) { +u8* preprocessPadsFile(u8 *data, u32 size, u32 *outSize) { u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_PADS); u8* dst = sysMemZeroAlloc(newSizeEstimated); diff --git a/port/pdextract/ext_file_tiles.c b/port/pdextract/ext_file_tiles.c index ce32f3954..8e3c152aa 100644 --- a/port/pdextract/ext_file_tiles.c +++ b/port/pdextract/ext_file_tiles.c @@ -86,7 +86,7 @@ u32 convert_tiles(u8 *dst, u8 *src, size_t srclen) return ALIGN16(cur_dst_offset); } -u8 *preprocessTilesFile_x64(u8 *data, u32 size, u32 *outSize) +u8 *preprocessTilesFile(u8 *data, u32 size, u32 *outSize) { u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_TILES); u8 *dst = sysMemZeroAlloc(newSizeEstimated); diff --git a/port/pdextract/ext_fonts.c b/port/pdextract/ext_fonts.c index 6d8c49bdf..b2f9ab1b8 100644 --- a/port/pdextract/ext_fonts.c +++ b/port/pdextract/ext_fonts.c @@ -48,7 +48,7 @@ struct fontdef { int pal_extra_chars; }; -u8* preprocessFont_x64(u8 *src, u32 srclen, u32 *outSize) +u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) { int num_chars = 94; #if VERSION == VERSION_PAL_FINAL diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c index 4dbf7afe2..ad2f6ba6f 100644 --- a/port/pdextract/ext_setups.c +++ b/port/pdextract/ext_setups.c @@ -1182,7 +1182,7 @@ static int convert_setup(u8 *dst, u8 *src, u32 srclen) return dstpos; } -u8 *preprocessSetupFile_x64(u8 *data, u32 size, u32 *outSize) { +u8 *preprocessSetupFile(u8 *data, u32 size, u32 *outSize) { u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_SETUP); u8 *dst = sysMemZeroAlloc(newSizeEstimated); diff --git a/port/src/preprocess.c b/port/src/preprocess.c index f575117a4..791008ca3 100644 --- a/port/src/preprocess.c +++ b/port/src/preprocess.c @@ -154,859 +154,6 @@ static inline void preprocessALBank(ALBank *bank, u8 *bankBase) } } -static inline void preprocessGfx(Gfx *gdl, u8 *base, uintptr_t ofs) -{ - while (gdl) { - const s8 opcode = (s8)gdl->bytes[0]; - PD_SWAP_VAL(gdl->words.w0); - PD_SWAP_VAL(gdl->words.w1); - if (opcode == (s8)G_ENDDL) { - break; - } - - // mark all addresses in the DL as segmented - switch (opcode) { - case (s8)G_SETTIMG: - case (s8)G_SETCIMG: - case (s8)G_SETZIMG: - case G_MOVEMEM: - case G_MTX: - case G_VTX: - case G_COL: - case G_DL: - gdl->words.w1 |= 1; - break; - default: - break; - } - - ++gdl; - } -} - -static inline void preprocessVtx(Vtx *vtx) -{ - PD_SWAP_VAL(vtx->x); - PD_SWAP_VAL(vtx->y); - PD_SWAP_VAL(vtx->z); - PD_SWAP_VAL(vtx->s); - PD_SWAP_VAL(vtx->t); -} - -static u8 *preprocessModelGunDL(struct modelrodata_gundl *gundl, u8 *base, u32 ofs) -{ - PD_SWAP_PTR(gundl->baseaddr); - PD_SWAP_PTR(gundl->vertices); - PD_SWAP_VAL(gundl->numvertices); - PD_SWAP_VAL(gundl->unk12); - - Vtx *vtx = PD_PTR_BASEOFS(gundl->vertices, base, ofs); - for (s16 i = 0; i < gundl->numvertices; ++i, ++vtx) { - preprocessVtx(vtx); - } - - if (gundl->opagdl) { - PD_SWAP_PTR(gundl->opagdl); - preprocessGfx(PD_PTR_BASEOFS(gundl->opagdl, base, ofs), base, ofs); - gundl->opagdl = SEGADDR(gundl->opagdl); - } - - if (gundl->xlugdl) { - PD_SWAP_PTR(gundl->xlugdl); - preprocessGfx(PD_PTR_BASEOFS(gundl->xlugdl, base, ofs), base, ofs); - gundl->xlugdl = SEGADDR(gundl->xlugdl); - } - - u8 *lowptr = (u8 *)gundl->vertices; - if (gundl->opagdl && (u8 *)gundl->opagdl < lowptr) { - lowptr = (u8 *)gundl->opagdl; - } - if (gundl->xlugdl && (u8 *)gundl->xlugdl < lowptr) { - lowptr = (u8 *)gundl->xlugdl; - } - - return lowptr; -} - -static u8 *preprocessModelDL(struct modelrodata_dl *dl, u8 *base, u32 ofs) -{ - PD_SWAP_PTR(dl->colours); - PD_SWAP_PTR(dl->vertices); - - PD_SWAP_VAL(dl->numvertices); - PD_SWAP_VAL(dl->numcolours); - PD_SWAP_VAL(dl->mcount); - PD_SWAP_VAL(dl->rwdataindex); - - Vtx *vtx = PD_PTR_BASEOFS(dl->vertices, base, ofs); - for (s16 i = 0; i < dl->numvertices; ++i, ++vtx) { - preprocessVtx(vtx); - } - - if (dl->opagdl) { - PD_SWAP_PTR(dl->opagdl); - preprocessGfx(PD_PTR_BASEOFS(dl->opagdl, base, ofs), base, ofs); - dl->opagdl = SEGADDR(dl->opagdl); - } - - if (dl->xlugdl) { - PD_SWAP_PTR(dl->xlugdl); - preprocessGfx(PD_PTR_BASEOFS(dl->xlugdl, base, ofs), base, ofs); - dl->xlugdl = SEGADDR(dl->xlugdl); - } - - u8 *lowptr = (u8 *)dl->vertices; - if (dl->colours && (u8 *)dl->colours < lowptr) { - lowptr = (u8 *)dl->colours; - } - if (dl->opagdl && (u8 *)dl->opagdl < lowptr) { - lowptr = (u8 *)dl->opagdl; - } - if (dl->xlugdl && (u8 *)dl->xlugdl < lowptr) { - lowptr = (u8 *)dl->xlugdl; - } - - return lowptr; -} - -// returns the pointer to the start of the non-texture graphics data (verts, gdls, etc) -static u8 *preprocessModelNode(struct modelnode *node, u8 *base, u32 ofs) -{ - u8 *lowptr = NULL; - u8 *tmp = NULL; - - while (node) { - PD_SWAP_VAL(node->type); - PD_SWAP_PTR(node->child); - PD_SWAP_PTR(node->next); - PD_SWAP_PTR(node->parent); - PD_SWAP_PTR(node->rodata); - - if (node->rodata) { - union modelrodata* ro = PD_PTR_BASEOFS(node->rodata, base, ofs); - if (!lowptr || ((u8 *)node->rodata < lowptr)) { - lowptr = (u8 *)node->rodata; - } - - switch (node->type & 0xff) { - case MODELNODETYPE_CHRINFO: - PD_SWAP_VAL(ro->chrinfo.animpart); - PD_SWAP_VAL(ro->chrinfo.mtxindex); - PD_SWAP_VAL(ro->chrinfo.rwdataindex); - PD_SWAP_VAL(ro->chrinfo.unk04); - break; - case MODELNODETYPE_POSITION: - PD_SWAP_VAL(ro->position.drawdist); - PD_SWAP_VAL(ro->position.pos); - PD_SWAP_VAL(ro->position.part); - PD_SWAP_VAL(ro->position.mtxindex0); - PD_SWAP_VAL(ro->position.mtxindex1); - PD_SWAP_VAL(ro->position.mtxindex2); - break; - case MODELNODETYPE_GUNDL: - tmp = preprocessModelGunDL(&ro->gundl, base, ofs); - if (tmp && (!lowptr || tmp < lowptr)) { - lowptr = tmp; - } - break; - case MODELNODETYPE_05: - break; - case MODELNODETYPE_DISTANCE: - PD_SWAP_VAL(ro->distance.near); - PD_SWAP_VAL(ro->distance.far); - PD_SWAP_VAL(ro->distance.rwdataindex); - PD_SWAP_PTR(ro->distance.target); - // TODO: assuming target points to one of the nodes we'll swap by following node->next - break; - case MODELNODETYPE_REORDER: - PD_SWAP_VAL(ro->reorder.unk00); - PD_SWAP_VAL(ro->reorder.unk04); - PD_SWAP_VAL(ro->reorder.unk08); - PD_SWAP_VAL(ro->reorder.unk0c[0]); - PD_SWAP_VAL(ro->reorder.unk0c[1]); - PD_SWAP_VAL(ro->reorder.unk0c[2]); - PD_SWAP_VAL(ro->reorder.rwdataindex); - PD_SWAP_VAL(ro->reorder.side); - PD_SWAP_PTR(ro->reorder.unk18); - PD_SWAP_PTR(ro->reorder.unk1c); - break; - case MODELNODETYPE_BBOX: - PD_SWAP_VAL(ro->bbox.xmin); - PD_SWAP_VAL(ro->bbox.xmax); - PD_SWAP_VAL(ro->bbox.ymin); - PD_SWAP_VAL(ro->bbox.ymax); - PD_SWAP_VAL(ro->bbox.zmin); - PD_SWAP_VAL(ro->bbox.zmax); - PD_SWAP_VAL(ro->bbox.hitpart); - break; - case MODELNODETYPE_0B: - PD_SWAP_PTR(ro->type0b.baseaddr); - PD_SWAP_VAL(ro->type0b.rwdataindex); - PD_SWAP_VAL(ro->type0b.unk00); - PD_SWAP_PTR(ro->type0b.unk3c); - // TODO: do we need to swap the rest of the words? - break; - case MODELNODETYPE_CHRGUNFIRE: - PD_SWAP_PTR(ro->chrgunfire.baseaddr); - PD_SWAP_PTR(ro->chrgunfire.texture); - PD_SWAP_VAL(ro->chrgunfire.rwdataindex); - PD_SWAP_VAL(ro->chrgunfire.pos); - PD_SWAP_VAL(ro->chrgunfire.dim); - PD_SWAP_VAL(ro->chrgunfire.unk1c); - // TODO: do we swap contents of *texture or is it part of mdl->textureconfigs[]? - break; - case MODELNODETYPE_0D: - PD_SWAP_PTR(ro->type0d.baseaddr); - PD_SWAP_PTR(ro->type0d.unk10); - PD_SWAP_PTR(ro->type0d.unk14); - // TODO: do we need to swap the rest of the words? - break; - case MODELNODETYPE_0E: - case MODELNODETYPE_0F: - break; - case MODELNODETYPE_11: - PD_SWAP_PTR(ro->type11.unk14); - // TODO: do we need to swap the rest of the words? - break; - case MODELNODETYPE_TOGGLE: - PD_SWAP_VAL(ro->toggle.rwdataindex); - PD_SWAP_PTR(ro->toggle.target); - // TODO: assuming target points to one of the nodes we'll swap by following node->next - break; - case MODELNODETYPE_POSITIONHELD: - PD_SWAP_VAL(ro->positionheld.mtxindex); - PD_SWAP_VAL(ro->positionheld.pos); - break; - case MODELNODETYPE_STARGUNFIRE: - PD_SWAP_VAL(ro->stargunfire.unk00); - PD_SWAP_PTR(ro->stargunfire.baseaddr); - if (ro->stargunfire.gdl) { - PD_SWAP_PTR(ro->stargunfire.gdl); - preprocessGfx(PD_PTR_BASEOFS(ro->stargunfire.gdl, base, ofs), base, ofs); - ro->stargunfire.gdl = SEGADDR(ro->stargunfire.gdl); - if (!lowptr || (u8 *)ro->stargunfire.gdl < lowptr) { - lowptr = (u8 *)ro->stargunfire.gdl; - } - } - if (ro->stargunfire.vertices) { - PD_SWAP_PTR(ro->stargunfire.vertices); - Vtx *vtx = PD_PTR_BASEOFS(ro->stargunfire.vertices, base, ofs); - for (s32 i = 0; i < 4 * ro->stargunfire.unk00; ++i, ++vtx) { - preprocessVtx(vtx); - } - if (!lowptr || (u8 *)ro->stargunfire.vertices < lowptr) { - lowptr = (u8 *)ro->stargunfire.vertices; - } - } - break; - case MODELNODETYPE_HEADSPOT: - PD_SWAP_VAL(ro->headspot.rwdataindex); - break; - case MODELNODETYPE_DL: - tmp = preprocessModelDL(&ro->dl, base, ofs); - if (tmp && (!lowptr || tmp < lowptr)) { - lowptr = tmp; - } - break; - case 0x19: - PD_SWAP_VAL(ro->type19.numvertices); - for (s32 i = 0; i < ARRAYCOUNT(ro->type19.vertices); ++i) { - PD_SWAP_VAL(ro->type19.vertices[i]); - } - break; - default: - sysLogPrintf(LOG_ERROR, "preprocessModelNode: node at %p: unknown node->type: 0x%02x", node, node->type & 0xff); - break; - } - } - - if (node->child) { - node = PD_PTR_BASEOFS(node->child, base, ofs); - } else { - while (node) { - if (node->next) { - node = PD_PTR_BASEOFS(node->next, base, ofs); - break; - } - if (node->parent) { - node = PD_PTR_BASEOFS(node->parent, base, ofs); - } else { - node = NULL; - } - } - } - } - - return (u8 *)UNSEGADDR(lowptr); -} - -static inline void preprocessPadData(u8 *ptr, u32 size) -{ - // we'll try to avoid overwriting the next pad if possible in case the flags are wrong - u8 *end = ptr + size; - - // for some insane reason pads are packed - // header is always 1 word, the rest of the fields depends on the flags - u32 *header = (u32 *) ptr; - PD_SWAP_VAL(header[0]); - - const u32 flags = header[0] >> 14; - - ptr += 4; - - if ((flags & PADFLAG_INTPOS) || size <= 12) { - // position is 3x s16 - s16 *sbuffer = (s16 *) ptr; - PD_SWAP_VAL(sbuffer[0]); - PD_SWAP_VAL(sbuffer[1]); - PD_SWAP_VAL(sbuffer[2]); - ptr += 8; - } else if (size > 12) { - // position is 3x f32 - f32 *fbuffer = (f32 *) ptr; - PD_SWAP_VAL(fbuffer[0]); - PD_SWAP_VAL(fbuffer[1]); - PD_SWAP_VAL(fbuffer[2]); - ptr += 12; - } - - if (!(flags & (PADFLAG_UPALIGNTOX | PADFLAG_UPALIGNTOY | PADFLAG_UPALIGNTOZ)) && (end >= ptr + 12)) { - // up vector, 3x f32 - f32 *fbuffer = (f32 *) ptr; - PD_SWAP_VAL(fbuffer[0]); - PD_SWAP_VAL(fbuffer[1]); - PD_SWAP_VAL(fbuffer[2]); - ptr += 12; - } - - if (!(flags & (PADFLAG_LOOKALIGNTOX | PADFLAG_LOOKALIGNTOY | PADFLAG_LOOKALIGNTOZ)) && (end >= ptr + 12)) { - // look vector, 3x f32 - f32 *fbuffer = (f32 *) ptr; - PD_SWAP_VAL(fbuffer[0]); - PD_SWAP_VAL(fbuffer[1]); - PD_SWAP_VAL(fbuffer[2]); - ptr += 12; - } - - if ((flags & PADFLAG_HASBBOXDATA) && (end >= ptr + 24)) { - // bbox, 3x f32 mins + 3x f32 maxs - f32 *fbuffer = (f32 *) ptr; - PD_SWAP_VAL(fbuffer[0]); - PD_SWAP_VAL(fbuffer[1]); - PD_SWAP_VAL(fbuffer[2]); - PD_SWAP_VAL(fbuffer[3]); - PD_SWAP_VAL(fbuffer[4]); - PD_SWAP_VAL(fbuffer[5]); - } -} - -static inline void preprocessDefaultPropObj(struct defaultobj *obj) -{ - PD_SWAP_PTR(obj->projectile); - PD_SWAP_PTR(obj->geoblock); - PD_SWAP_PTR(obj->prop); - PD_SWAP_PTR(obj->model); - PD_SWAP_VAL(obj->flags); - PD_SWAP_VAL(obj->flags2); - PD_SWAP_VAL(obj->flags3); - PD_SWAP_VAL(obj->hidden); - PD_SWAP_VAL(obj->damage); - PD_SWAP_VAL(obj->maxdamage); - PD_SWAP_VAL(obj->extrascale); - PD_SWAP_VAL(obj->floorcol); - PD_SWAP_VAL(obj->modelnum); - PD_SWAP_VAL(obj->pad); - for (s32 i = 0; i < 3; ++i) { - for (s32 j = 0; j < 3; ++j) { - PD_SWAP_VAL(obj->realrot[i][j]); - } - } -} - -static inline void preprocessDefaultPropObjHdr(struct defaultobj *obj) -{ - // don't touch the other fields - PD_SWAP_VAL(obj->extrascale); -} - -static inline void preprocessTvScreenPropObj(struct tvscreen *scr) -{ - PD_SWAP_PTR(scr->cmdlist); - PD_SWAP_PTR(scr->tconfig); - PD_SWAP_VAL(scr->offset); - PD_SWAP_VAL(scr->pause60); - PD_SWAP_VAL(scr->rot); - PD_SWAP_VAL(scr->xscale); - PD_SWAP_VAL(scr->xscalefrac); - PD_SWAP_VAL(scr->xscaleinc); - PD_SWAP_VAL(scr->xscaleold); - PD_SWAP_VAL(scr->xscalenew); - PD_SWAP_VAL(scr->yscale); - PD_SWAP_VAL(scr->yscalefrac); - PD_SWAP_VAL(scr->yscaleinc); - PD_SWAP_VAL(scr->yscaleold); - PD_SWAP_VAL(scr->yscalenew); - PD_SWAP_VAL(scr->xmid); - PD_SWAP_VAL(scr->xmidfrac); - PD_SWAP_VAL(scr->xmidinc); - PD_SWAP_VAL(scr->xmidold); - PD_SWAP_VAL(scr->xmidnew); - PD_SWAP_VAL(scr->ymid); - PD_SWAP_VAL(scr->ymidfrac); - PD_SWAP_VAL(scr->ymidinc); - PD_SWAP_VAL(scr->ymidold); - PD_SWAP_VAL(scr->ymidnew); - PD_SWAP_VAL(scr->colfrac); - PD_SWAP_VAL(scr->colinc); -} - -static inline void preprocessHovPropObj(struct hov *hov) -{ - // don't think anything actually has to be swapped here -} - -static void preprocessPropObj(struct defaultobj *obj) -{ - // TODO: help me jesus - switch (obj->type) { - case OBJTYPE_GRENADEPROB: { - struct grenadeprobobj *grenadeprob = (struct grenadeprobobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_VAL(grenadeprob->chrnum); - PD_SWAP_VAL(grenadeprob->probability); - break; - } - case OBJTYPE_CHR: { - struct packedchr *chr = (struct packedchr *)obj; - PD_SWAP_VAL(chr->chrindex); - PD_SWAP_VAL(chr->spawnflags); - PD_SWAP_VAL(chr->chrnum); - PD_SWAP_VAL(chr->padnum); - PD_SWAP_VAL(chr->ailistnum); - PD_SWAP_VAL(chr->padpreset); - PD_SWAP_VAL(chr->chrpreset); - PD_SWAP_VAL(chr->hearscale); - PD_SWAP_VAL(chr->viewdist); - PD_SWAP_VAL(chr->flags); - PD_SWAP_VAL(chr->flags2); - PD_SWAP_VAL(chr->chair); - PD_SWAP_VAL(chr->convtalk); - break; - } - case OBJTYPE_DOOR: { - struct doorobj *door = (struct doorobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_PTR(door->sibling); - PD_SWAP_VAL(door->maxfrac); - PD_SWAP_VAL(door->perimfrac); - PD_SWAP_VAL(door->accel); - PD_SWAP_VAL(door->decel); - PD_SWAP_VAL(door->maxspeed); - PD_SWAP_VAL(door->frac); - PD_SWAP_VAL(door->fracspeed); - PD_SWAP_VAL(door->startpos); - PD_SWAP_VAL(door->keyflags); - PD_SWAP_VAL(door->autoclosetime); - PD_SWAP_VAL(door->doorflags); - PD_SWAP_VAL(door->doortype); - PD_SWAP_VAL(door->fadealpha); - PD_SWAP_VAL(door->xludist); - PD_SWAP_VAL(door->opadist); - break; - } - case OBJTYPE_DOORSCALE: { - struct doorscaleobj *doorsc = (struct doorscaleobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_VAL(doorsc->scale); - break; - } - case OBJTYPE_WEAPON: { - struct weaponobj *wpn = (struct weaponobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_PTR(wpn->dualweapon); - PD_SWAP_VAL(wpn->team); - break; - } - case OBJTYPE_KEY: { - struct keyobj *key = (struct keyobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_VAL(key->keyflags); - break; - } - case OBJTYPE_CCTV: { - struct cctvobj *cctv = (struct cctvobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_VAL(cctv->yzero); - PD_SWAP_VAL(cctv->yrot); - PD_SWAP_VAL(cctv->yleft); - PD_SWAP_VAL(cctv->yright); - PD_SWAP_VAL(cctv->yspeed); - PD_SWAP_VAL(cctv->ymaxspeed); - PD_SWAP_VAL(cctv->maxdist); - PD_SWAP_VAL(cctv->xzero); - PD_SWAP_VAL(cctv->seebondtime60); - PD_SWAP_VAL(cctv->lookatpadnum); - PD_SWAP_VAL(cctv->toleft); - break; - } - case OBJTYPE_AUTOGUN: { - struct autogunobj *agun = (struct autogunobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_VAL(agun->targetpad); - PD_SWAP_VAL(agun->yzero); - PD_SWAP_VAL(agun->ymaxleft); - PD_SWAP_VAL(agun->ymaxright); - PD_SWAP_VAL(agun->yrot); - PD_SWAP_VAL(agun->yspeed); - PD_SWAP_VAL(agun->xzero); - PD_SWAP_VAL(agun->xrot); - PD_SWAP_VAL(agun->xspeed); - PD_SWAP_VAL(agun->maxspeed); - PD_SWAP_VAL(agun->aimdist); - PD_SWAP_VAL(agun->barrelspeed); - PD_SWAP_VAL(agun->barrelrot); - PD_SWAP_VAL(agun->allowsoundframe); - PD_SWAP_PTR(agun->target); - break; - } - case OBJTYPE_SINGLEMONITOR: { - struct singlemonitorobj *mon = (struct singlemonitorobj *)obj; - preprocessDefaultPropObj(obj); - preprocessTvScreenPropObj((struct tvscreen *)&mon->screen); - PD_SWAP_VAL(mon->owneroffset); - break; - } - case OBJTYPE_MULTIMONITOR: { - struct multimonitorobj *mmon = (struct multimonitorobj *)obj; - preprocessDefaultPropObj(obj); - preprocessTvScreenPropObj((struct tvscreen *)&mmon->screens[0]); - preprocessTvScreenPropObj((struct tvscreen *)&mmon->screens[1]); - preprocessTvScreenPropObj((struct tvscreen *)&mmon->screens[2]); - preprocessTvScreenPropObj((struct tvscreen *)&mmon->screens[3]); - break; - } - case OBJTYPE_SHIELD: { - struct shieldobj *shld = (struct shieldobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_VAL(shld->initialamount); - PD_SWAP_VAL(shld->amount); - break; - } - case OBJTYPE_TINTEDGLASS: { - struct tintedglassobj *tgls = (struct tintedglassobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_VAL(tgls->xludist); - PD_SWAP_VAL(tgls->opadist); - PD_SWAP_VAL(tgls->opacity); - PD_SWAP_VAL(tgls->portalnum); - PD_SWAP_VAL(tgls->unk64); - break; - } - case OBJTYPE_LIFT: { - struct liftobj *lift = (struct liftobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_PTR(lift->doors[0]); - PD_SWAP_PTR(lift->doors[1]); - PD_SWAP_PTR(lift->doors[2]); - PD_SWAP_PTR(lift->doors[3]); - PD_SWAP_VAL(lift->pads[0]); - PD_SWAP_VAL(lift->pads[1]); - PD_SWAP_VAL(lift->pads[2]); - PD_SWAP_VAL(lift->pads[3]); - PD_SWAP_VAL(lift->dist); - PD_SWAP_VAL(lift->speed); - PD_SWAP_VAL(lift->accel); - PD_SWAP_VAL(lift->maxspeed); - break; - } - case OBJTYPE_HOVERPROP: { - struct hoverpropobj *hprop = (struct hoverpropobj *)obj; - preprocessDefaultPropObj(obj); - preprocessHovPropObj(&hprop->hov); - break; - } - case OBJTYPE_HOVERBIKE: { - struct hoverbikeobj *hbike = (struct hoverbikeobj *)obj; - preprocessDefaultPropObj(obj); - preprocessHovPropObj(&hbike->hov); - break; - } - case OBJTYPE_FAN: { - struct fanobj *fan = (struct fanobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_VAL(fan->yrot); - PD_SWAP_VAL(fan->yrotprev); - PD_SWAP_VAL(fan->ymaxspeed); - PD_SWAP_VAL(fan->yspeed); - PD_SWAP_VAL(fan->yaccel); - break; - } - case OBJTYPE_GLASS: { - struct glassobj *gls = (struct glassobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_VAL(gls->portalnum); - break; - } - case OBJTYPE_AMMOCRATE: { - struct ammocrateobj *ammo = (struct ammocrateobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_VAL(ammo->ammotype); - break; - } - case OBJTYPE_MULTIAMMOCRATE: { - struct multiammocrateobj *mammo = (struct multiammocrateobj *)obj; - preprocessDefaultPropObj(obj); - for (s32 i = 0; i < ARRAYCOUNT(mammo->slots); ++i) { - PD_SWAP_VAL(mammo->slots[i].modelnum); - PD_SWAP_VAL(mammo->slots[i].quantity); - } - break; - } - case OBJTYPE_TRUCK: { - struct truckobj *truck = (struct truckobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_PTR(truck->ailist); - break; - } - case OBJTYPE_HOVERCAR: { - struct hovercarobj *car = (struct hovercarobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_PTR(car->ailist); - break; - } - case OBJTYPE_CHOPPER: { - struct chopperobj *chop = (struct chopperobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_PTR(chop->ailist); - break; - } - case OBJTYPE_HELI: { - struct heliobj *heli = (struct heliobj *)obj; - preprocessDefaultPropObj(obj); - PD_SWAP_PTR(heli->ailist); - break; - } - case OBJTYPE_TAG: { - struct tag *tag = (struct tag *)obj; - PD_SWAP_PTR(tag->next); - PD_SWAP_PTR(tag->obj); - PD_SWAP_VAL(tag->cmdoffset); - PD_SWAP_VAL(tag->tagnum); - break; - } - case OBJTYPE_RENAMEOBJ: { - struct textoverride *over = (struct textoverride *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(over->next); - PD_SWAP_PTR(over->obj); - PD_SWAP_VAL(over->objoffset); - PD_SWAP_VAL(over->weapon); - PD_SWAP_VAL(over->obtaintext); - PD_SWAP_VAL(over->ownertext); - PD_SWAP_VAL(over->inventorytext); - PD_SWAP_VAL(over->inventory2text); - PD_SWAP_VAL(over->pickuptext); - break; - } - case OBJTYPE_BRIEFING: { - struct briefingobj *brief = (struct briefingobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(brief->next); - PD_SWAP_VAL(brief->type); - PD_SWAP_VAL(brief->text); - break; - } - case OBJTYPE_CAMERAPOS: { - struct cameraposobj *campos = (struct cameraposobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_VAL(campos->x); - PD_SWAP_VAL(campos->y); - PD_SWAP_VAL(campos->z); - PD_SWAP_VAL(campos->theta); - PD_SWAP_VAL(campos->verta); - PD_SWAP_VAL(campos->pad); - break; - } - case OBJTYPE_BEGINOBJECTIVE: { - struct objective *objective = (struct objective *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_VAL(objective->index); - PD_SWAP_VAL(objective->text); - PD_SWAP_VAL(objective->unk0c); - break; - } - case OBJTYPE_ENDOBJECTIVE: { - break; - } - case OBJTYPE_PADEFFECT: { - struct padeffectobj *padeff = (struct padeffectobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_VAL(padeff->pad); - PD_SWAP_VAL(padeff->effect); - break; - } - case OBJTYPE_LINKGUNS: { - struct linkgunsobj *linkg = (struct linkgunsobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_VAL(linkg->offset1); - PD_SWAP_VAL(linkg->offset2); - break; - } - case OBJTYPE_LINKLIFTDOOR: { - struct linkliftdoorobj *linkd = (struct linkliftdoorobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(linkd->door); - PD_SWAP_PTR(linkd->lift); - PD_SWAP_PTR(linkd->next); - PD_SWAP_VAL(linkd->stopnum); - break; - } - case OBJTYPE_SAFEITEM: { - struct safeitemobj *linki = (struct safeitemobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(linki->item); - PD_SWAP_PTR(linki->safe); - PD_SWAP_PTR(linki->door); - PD_SWAP_PTR(linki->next); - break; - } - case OBJTYPE_PADLOCKEDDOOR: { - struct padlockeddoorobj *linkp = (struct padlockeddoorobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(linkp->door); - PD_SWAP_PTR(linkp->lock); - PD_SWAP_PTR(linkp->next); - break; - } - case OBJTYPE_CONDITIONALSCENERY: { - struct linksceneryobj *links = (struct linksceneryobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(links->trigger); - PD_SWAP_PTR(links->unexp); - PD_SWAP_PTR(links->exp); - PD_SWAP_PTR(links->next); - break; - } - case OBJTYPE_BLOCKEDPATH: { - struct blockedpathobj *blkp = (struct blockedpathobj *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(blkp->blocker); - PD_SWAP_PTR(blkp->next); - PD_SWAP_VAL(blkp->waypoint1); - PD_SWAP_VAL(blkp->waypoint2); - break; - } - case OBJTYPE_MINE: - case OBJTYPE_ESCASTEP: - case OBJTYPE_HANGINGMONITORS: - case OBJTYPE_BASIC: - case OBJTYPE_ALARM: - case OBJTYPE_DEBRIS: - case OBJTYPE_GASBOTTLE: - case OBJTYPE_29: - case OBJTYPE_SAFE: - case OBJTYPE_HAT: { - preprocessDefaultPropObj(obj); - break; - } - case OBJECTIVETYPE_ENTERROOM: { - struct criteria_roomentered *obte = (struct criteria_roomentered *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(obte->next); - PD_SWAP_VAL(obte->pad); - PD_SWAP_VAL(obte->status); - break; - } - case OBJECTIVETYPE_THROWINROOM: { - struct criteria_throwinroom *obtt = (struct criteria_throwinroom *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(obtt->next); - PD_SWAP_VAL(obtt->unk04); - PD_SWAP_VAL(obtt->pad); - PD_SWAP_VAL(obtt->status); - break; - } - case OBJECTIVETYPE_HOLOGRAPH: { - struct criteria_holograph *obth = (struct criteria_holograph *)obj; - preprocessDefaultPropObjHdr(obj); - PD_SWAP_PTR(obth->next); - PD_SWAP_VAL(obth->obj); - PD_SWAP_VAL(obth->status); - break; - } - case OBJECTIVETYPE_DESTROYOBJ: - case OBJECTIVETYPE_COMPFLAGS: - case OBJECTIVETYPE_FAILFLAGS: - case OBJECTIVETYPE_COLLECTOBJ: - case OBJECTIVETYPE_THROWOBJ: { - u32 *cmd = (u32 *)obj; - PD_SWAP_VAL(cmd[1]); - break; - } - default: { - sysFatalError("Unknown object type in prop list: %02x\nat %p", obj->type, obj); - break; - } - } -} - -static void preprocessIntroScript(s32 *cmd) -{ - while (cmd[0] != PD_BE32(INTROCMD_END)) { - PD_SWAP_VAL(cmd[0]); - switch (cmd[0]) { - case INTROCMD_HILL: - case INTROCMD_OUTFIT: - case INTROCMD_CREDITOFFSET: - case INTROCMD_4: - PD_SWAP_VAL(cmd[1]); - cmd += 2; - break; - case INTROCMD_SPAWN: - case INTROCMD_CASE: - case INTROCMD_CASERESPAWN: - case INTROCMD_WATCHTIME: - PD_SWAP_VAL(cmd[1]); - PD_SWAP_VAL(cmd[2]); - cmd += 3; - break; - case INTROCMD_AMMO: - case INTROCMD_WEAPON: - PD_SWAP_VAL(cmd[1]); - PD_SWAP_VAL(cmd[2]); - PD_SWAP_VAL(cmd[3]); - cmd += 4; - break; - case INTROCMD_3: - PD_SWAP_VAL(cmd[1]); - PD_SWAP_VAL(cmd[2]); - PD_SWAP_VAL(cmd[3]); - PD_SWAP_VAL(cmd[4]); - PD_SWAP_VAL(cmd[5]); - PD_SWAP_VAL(cmd[6]); - PD_SWAP_VAL(cmd[7]); - cmd += 8; - break; - case INTROCMD_6: - PD_SWAP_VAL(cmd[1]); - PD_SWAP_VAL(cmd[2]); - PD_SWAP_VAL(cmd[3]); - PD_SWAP_VAL(cmd[4]); - PD_SWAP_VAL(cmd[5]); - PD_SWAP_VAL(cmd[6]); - PD_SWAP_VAL(cmd[7]); - PD_SWAP_VAL(cmd[8]); - PD_SWAP_VAL(cmd[9]); - cmd += 10; - break; - default: - cmd += 1; - break; - } - } - PD_SWAP_VAL(cmd[0]); -} - u8* preprocessAnimations(u8* data, u32 size, u32* outSize) { // set the anim table pointers as well @@ -1068,43 +215,14 @@ u8* preprocessMpConfigs(u8* data, u32 size, u32* outSize) return 0; } -u8* preprocessFont(u8* data, u32 size, u32* outSize) -{ - return; - struct font *fnt = (struct font *)data; - - for (s32 i = 0; i < ARRAYCOUNT(fnt->kerning); ++i) { - PD_SWAP_VAL(fnt->kerning[i]); - } - - s32 numchars = 94; - -#if PAL - // PAL has more characters in these fonts - extern u8 *_fonthandelgothicsmSegmentRomStart; - extern u8 *_fonthandelgothicxsSegmentRomStart; - extern u8 *_fonthandelgothicmdSegmentRomStart; - if (data == _fonthandelgothicsmSegmentRomStart - || data == _fonthandelgothicxsSegmentRomStart - || data == _fonthandelgothicmdSegmentRomStart) { - numchars = 135; - } -#endif - - for (s32 i = 0; i < numchars; ++i) { - PD_SWAP_VAL(fnt->chars[i].kerningindex); - PD_SWAP_PTR(fnt->chars[i].pixeldata); - } - return 0; -} - u8* preprocessJpnFont(u8* data, u32 size, u32* outSize) { // ??? return 0; } -u8* preprocessALBankFile(u8* data, u32 size, u32* outSize) +// to be removed eventually #TODO +u8* preprocessALBankFile_x86(u8* data, u32 size, u32* outSize) { memset(swapmap, 0, sizeof(swapmap)); @@ -1158,296 +276,6 @@ u8* preprocessTexturesList(u8* data, u32 size, u32* outSize) return 0; } -void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) -{ - for (uint32_t i = 0; i < size_bytes; i += 4, ++dest) { - *dest = PD_BE32(*dest); - } -} - -void preprocessModel(u8 *base, u32 ofs) -{ - struct modeldef *mdl = (struct modeldef *)base; - - PD_SWAP_VAL(mdl->nummatrices); - PD_SWAP_VAL(mdl->numparts); - PD_SWAP_VAL(mdl->numtexconfigs); - PD_SWAP_VAL(mdl->rwdatalen); - PD_SWAP_VAL(mdl->scale); - - if (mdl->skel) { - PD_SWAP_PTR(mdl->skel); - if ((u32)mdl->skel >= 0x10000) { - // skeleton is a pointer instead of an index - // preprocessSkeleton((struct skeleton *)(base + (u32)mdl->skel)); // TODO - } - } - - if (mdl->parts) { - PD_SWAP_PTR(mdl->parts); - struct modelnode **parts = PD_PTR_BASEOFS(mdl->parts, base, ofs); - for (s16 i = 0; i < mdl->numparts; ++i) { - PD_SWAP_PTR(parts[i]); - } - s16 *partnums = (s16 *)&parts[mdl->numparts]; - for (s16 i = 0; i < mdl->numparts; ++i) { - PD_SWAP_VAL(partnums[i]); - } - } - - u8 *texturesEnd = NULL; - if (mdl->rootnode) { - PD_SWAP_PTR(mdl->rootnode); - texturesEnd = preprocessModelNode(PD_PTR_BASEOFS(mdl->rootnode, base, ofs), base, ofs); - } - - if (mdl->texconfigs) { - PD_SWAP_PTR(mdl->texconfigs); - struct textureconfig *texconfigs = PD_PTR_BASEOFS(mdl->texconfigs, base, ofs); - for (s16 i = 0; i < mdl->numtexconfigs; ++i) { - PD_SWAP_VAL(texconfigs[i].texturenum); - if ((texconfigs[i].texturenum & 0xf000000) == 0x5000000) { - // embedded texture; we need to unswizzle this - u8 *texdata = PD_PTR_BASEOFS(texconfigs[i].textureptr, base, ofs); - // figure out the max possible size the texture can have, because sometimes the texconfig is wrong - const u32 maxSize = (texturesEnd > texconfigs[i].textureptr) ? (texturesEnd - texconfigs[i].textureptr) : 0; - // figure out the format and unswizzle - const s32 format = texConfigToFormat(&texconfigs[i]); - texSwizzleInternal(texdata, texconfigs[i].width, texconfigs[i].height, format, maxSize); - - if (format == TEXFORMAT_RGBA32) { - // for some reason, RGBA32 embedded textures don't need to be byte-swapped, - // so we byte-swap them here, which will be undone when the renderer imports it - u32 size_bytes = texconfigs[i].width * texconfigs[i].height * 4; - preprocessTextureRGBA32Embedded((u32*)texdata, size_bytes); - } - } - } - } -} - -u8* preprocessLangFile(u8* data, u32 size, u32* outSize) -{ - // lang banks are just an offset table + text data right after - // offsets are from the beginning of the bank - // however we cannot byteswap them in advance because the length of the - // offset table is unknown, so that's done in lang.c on demand instead - return 0; -} - -u8* preprocessPadsFile(u8* data, u32 size, u32* outSize) -{ - struct padsfileheader *hdr = (void *)data; - - PD_SWAP_VAL(hdr->numpads); - PD_SWAP_VAL(hdr->numcovers); - - for (s32 i = 0; i < hdr->numpads; ++i) { - if (hdr->padoffsets[i]) { - PD_SWAP_VAL(hdr->padoffsets[i]); - const u32 size = (i + 1 < hdr->numpads && hdr->padoffsets[i + 1]) ? - (PD_BE16(hdr->padoffsets[i + 1]) - hdr->padoffsets[i]) : 0x40; - preprocessPadData(PD_PTR_BASE(hdr->padoffsets[i], hdr), size); - } - } - - if (hdr->numcovers && hdr->coversoffset) { - PD_SWAP_VAL(hdr->coversoffset); - struct coverdefinition *def = PD_PTR_BASE(hdr->coversoffset, hdr); - for (s32 i = 0; i < hdr->numcovers; ++i, ++def) { - PD_SWAP_VAL(def->flags); - PD_SWAP_VAL(def->look); - PD_SWAP_VAL(def->pos); - } - } - - if (hdr->waypointsoffset) { - PD_SWAP_VAL(hdr->waypointsoffset); - struct waypoint *wp = PD_PTR_BASE(hdr->waypointsoffset, hdr); - // the terminator is 0xFFFFFFFF, same for the s32 lists - // TODO: the game checks for >= 0, so maybe something's terminated with a random negative number? - while (wp->padnum != (s32)0xFFFFFFFF) { - PD_SWAP_VAL(wp->padnum); - PD_SWAP_VAL(wp->groupnum); - PD_SWAP_VAL(wp->step); - if (wp->neighbours) { - PD_SWAP_PTR(wp->neighbours); - s32 *nbr = PD_PTR_BASE(wp->neighbours, hdr); - while (*nbr != (s32)0xFFFFFFFF) { - PD_SWAP_VAL(*nbr); - ++nbr; - } - } - ++wp; - } - } - - if (hdr->waygroupsoffset) { - PD_SWAP_VAL(hdr->waygroupsoffset); - struct waygroup *wg = PD_PTR_BASE(hdr->waygroupsoffset, hdr); - while (wg->neighbours) { - PD_SWAP_VAL(wg->step); - if (wg->neighbours) { - PD_SWAP_PTR(wg->neighbours); - s32 *nbr = PD_PTR_BASE(wg->neighbours, hdr); - while (*nbr != (s32)0xFFFFFFFF) { - PD_SWAP_VAL(*nbr); - ++nbr; - } - } - if (wg->waypoints) { - PD_SWAP_PTR(wg->waypoints); - s32 *wgwp = PD_PTR_BASE(wg->waypoints, hdr); - while (*wgwp != (s32)0xFFFFFFFF) { - PD_SWAP_VAL(*wgwp); - ++wgwp; - } - } - ++wg; - } - } - return 0; -} - -u8* preprocessTilesFile(u8* data, u32 size, u32* outSize) -{ - u32 *roomTable = (u32 *)data; - PD_SWAP_VAL(roomTable[0]); - - const u32 numRooms = roomTable[0]; - ++roomTable; - - u32 *rooms = roomTable; - // rooms[numRooms] is the end offset - for (u32 i = 0; i <= numRooms; ++i) { - PD_SWAP_VAL(rooms[i]); - } - - struct geo *geo = (struct geo *)(data + rooms[0]); - struct geo *end = (struct geo *)(data + rooms[numRooms]); - - while (geo < end) { - PD_SWAP_VAL(geo->flags); - switch (geo->type) { - case GEOTYPE_TILE_I: { - struct geotilei *tile = (struct geotilei *)geo; - PD_SWAP_VAL(tile->floorcol); - PD_SWAP_VAL(tile->floortype); - for (u32 i = 0; i < geo->numvertices; ++i) { - PD_SWAP_VAL(tile->vertices[i][0]); - PD_SWAP_VAL(tile->vertices[i][1]); - PD_SWAP_VAL(tile->vertices[i][2]); - } - geo = (struct geo *)((u8 *)geo + (uintptr_t)(geo->numvertices - 0x40) * 6 + 0x18e); - break; - } - case GEOTYPE_TILE_F: { - struct geotilef *tile = (struct geotilef *)geo; - PD_SWAP_VAL(tile->floorcol); - PD_SWAP_VAL(tile->floortype); - for (u32 i = 0; i < geo->numvertices; ++i) { - PD_SWAP_VAL(tile->vertices[i].x); - PD_SWAP_VAL(tile->vertices[i].y); - PD_SWAP_VAL(tile->vertices[i].z); - } - geo = (struct geo *)((u8 *)geo + (uintptr_t)(geo->numvertices - 0x40) * 12 + 0x310); - break; - } - case GEOTYPE_BLOCK: { - struct geoblock *blk = (struct geoblock *)geo; - PD_SWAP_VAL(blk->ymin); - PD_SWAP_VAL(blk->ymax); - for (u32 i = 0; i < geo->numvertices; ++i) { - PD_SWAP_VAL(blk->vertices[i][0]); - PD_SWAP_VAL(blk->vertices[i][1]); - } - geo = (struct geo *)((u8 *)geo + sizeof(struct geoblock)); - break; - } - case GEOTYPE_CYL: { - struct geocyl *cyl = (struct geocyl *)geo; - PD_SWAP_VAL(cyl->x); - PD_SWAP_VAL(cyl->z); - PD_SWAP_VAL(cyl->radius); - PD_SWAP_VAL(cyl->ymin); - PD_SWAP_VAL(cyl->ymax); - geo = (struct geo *)((u8 *)geo + sizeof(struct geocyl)); - break; - } - default: - break; - } - } - return 0; -} - -u8* preprocessSetupFile(u8* data, u32 size, u32* outSize) -{ - struct stagesetup *set = (void *)data; - - if (set->intro) { - // intro commands are made up of a command id + up to 3 args, which can have any value, even 0x0c (end marker) - // so we have to swap each type by hand here as well - PD_SWAP_PTR(set->intro); - preprocessIntroScript(PD_PTR_BASE(set->intro, set)); - } - - if (set->props) { - PD_SWAP_PTR(set->props); - // commands are casted to non-trivial structs elsewhere, so we'll have to parse the fucking list - // and swap each type by hand - struct defaultobj *obj = PD_PTR_BASE(set->props, set); - while (obj->type != OBJTYPE_END) { - preprocessPropObj(obj); - obj = (struct defaultobj *)((u32 *)obj + setupGetCmdLength((u32 *)obj)); - } - } - - if (set->paths) { - PD_SWAP_PTR(set->paths); - struct path *p = PD_PTR_BASE(set->paths, set); - while ((u8 *)p < data + size && p->pads) { - PD_SWAP_PTR(p->pads); - s32 *pp = PD_PTR_BASE(p->pads, set); - while ((u8 *)pp < data + size) { - PD_SWAP_VAL(*pp); - if (*pp < 0) { - break; - } - ++pp; - } - ++p; - } - } - - if (set->ailists) { - PD_SWAP_PTR(set->ailists); - struct ailist *p = PD_PTR_BASE(set->ailists, set); - while ((u8 *)p < data + size && p->list) { - PD_SWAP_VAL(p->id); - PD_SWAP_PTR(p->list); - // the actual command lists are made up of variable length instructions, - // but they don't do any wonky word casting, so they should probably work as is - ++p; - } - } - - // the rest of the pointers are set after loading - return 0; -} - -u8* preprocessModelFile(u8* data, u32 size, u32* outSize) -{ - preprocessModel(data, 0x5000000); - return 0; -} - -u8* preprocessGunFile(u8* data, u32 size, u32* outSize) -{ - preprocessModel(data, 0x5000000); - return 0; -} - void preprocessBgSection1Header(u8 *data, u32 size) { u32 *header = (u32 *)data; @@ -1456,72 +284,6 @@ void preprocessBgSection1Header(u8 *data, u32 size) PD_SWAP_VAL(header[2]); // primcompsize } -#ifndef PLATFORM_64BIT -void preprocessBgSection1(u8 *data, u32 ofs) { - struct { - u32 unk00; - u32 roomsofs; - u32 portalsofs; - u32 commandsofs; - u32 lightsofs; - u32 stanofs; - } *header = (void *)data; - - PD_SWAP_VAL(header->unk00); - PD_SWAP_VAL(header->roomsofs); - PD_SWAP_VAL(header->portalsofs); - - struct bgroom *rm = PD_PTR_BASEOFS(header->roomsofs, data, ofs); - for (++rm; rm->unk00; ++rm) { - PD_SWAP_VAL(rm->unk00); - PD_SWAP_VAL(rm->pos); - } - - struct bgportal *portals = PD_PTR_BASEOFS(header->portalsofs, data, ofs); - s32 numportals = 0; - for (struct bgportal *prt = portals; prt->verticesoffset; ++prt) { - ++numportals; - } - - s32 maxbatchnum = 0; - for (s32 i = 0; i < numportals; ++i) { - PD_SWAP_VAL(portals[i].verticesoffset); - PD_SWAP_VAL(portals[i].roomnum1); - PD_SWAP_VAL(portals[i].roomnum2); - if (portals[i].verticesoffset > maxbatchnum) { - maxbatchnum = portals[i].verticesoffset; - } - } - - uintptr_t pvoffset = sizeof(portals[0]) * (numportals + 1); - for (s32 i = 1; i <= maxbatchnum; i++) { - struct portalvertices *pverts = PD_PTR_BASE(pvoffset, portals); - for (u32 j = 0; j < pverts->count; ++j) { - PD_SWAP_VAL(pverts->vertices[j]); - } - pvoffset += 4 + pverts->count * 12; - } - - if (header->commandsofs) { - PD_SWAP_VAL(header->commandsofs); - struct bgcmd *cmd = PD_PTR_BASEOFS(header->commandsofs, data, ofs); - for (; cmd->type != 0x00; cmd++) { - PD_SWAP_VAL(cmd->param); - } - } - - if (header->lightsofs) { - PD_SWAP_VAL(header->lightsofs); - // data swapping done later in preprocessBgLights - } - - if (header->stanofs) { - PD_SWAP_VAL(header->stanofs); - // unused, so won't swap the contents - } -} -#endif - void preprocessBgSection2Header(u8 *data, u32 size) { u16 *header = (u16 *)data; @@ -1565,67 +327,6 @@ void preprocessBgSection3(u8 *data, u32 size) } } -#ifndef PLATFORM_64BIT -void preprocessBgRoom(u8 *data, u32 ofs) { - struct roomgfxdata *rgfx = (void *)data; - - PD_SWAP_VAL(rgfx->numvertices); - PD_SWAP_VAL(rgfx->numcolours); - PD_SWAP_VAL(rgfx->numlights); - PD_SWAP_VAL(rgfx->lightsindex); - PD_SWAP_PTR(rgfx->vertices); - PD_SWAP_PTR(rgfx->opablocks); - PD_SWAP_PTR(rgfx->xlublocks); - PD_SWAP_PTR(rgfx->colours); - - // numvertices is actually 0 in the data because fuck you - const s32 numverts = ((uintptr_t) rgfx->colours - (uintptr_t) rgfx->vertices) / sizeof(Vtx); - Vtx *vertices = NULL; - if (rgfx->vertices) { - vertices = PD_PTR_BASEOFS(rgfx->vertices, data, ofs); - Vtx *vtx = vertices; - for (s32 i = 0; i < numverts; ++i, ++vtx) { - preprocessVtx(vtx); - } - } - - // here's hoping that xlublocks and opablocks aren't completely separate trees - - struct roomblock *blk = rgfx->blocks; - struct roomblock *end = (void *)vertices; - struct coord *tmp; - - for (; blk + 1 <= end; blk++) { - PD_SWAP_PTR(blk->next); - switch (blk->type) { - case ROOMBLOCKTYPE_LEAF: - if (blk->gdl) { - PD_SWAP_PTR(blk->gdl); - preprocessGfx(PD_PTR_BASEOFS(blk->gdl, data, ofs), data, ofs); - } - PD_SWAP_PTR(blk->vertices); - PD_SWAP_PTR(blk->colours); - break; - case ROOMBLOCKTYPE_PARENT: - PD_SWAP_PTR(blk->child); - PD_SWAP_PTR(blk->unk0c); - tmp = PD_PTR_BASEOFS(blk->unk0c, data, ofs); - for (s32 i = 0; i < 2; ++i) { - PD_SWAP_VAL(tmp[i].x); - PD_SWAP_VAL(tmp[i].y); - PD_SWAP_VAL(tmp[i].z); - } - if ((u8 *)tmp < (u8 *)end) { - end = (void *)tmp; - } - break; - default: - break; - } - } -} -#endif - void preprocessBgLights(u8 *data, u32 ofs) { struct light *lbase = (void *)data; diff --git a/port/src/romdata.c b/port/src/romdata.c index 92cda2416..515fff581 100644 --- a/port/src/romdata.c +++ b/port/src/romdata.c @@ -98,13 +98,6 @@ static struct romfile fileSlots[ROMDATA_MAX_FILES] = { #define ROMSEG_START(n) _ ## n ## SegmentRomStart #define ROMSEG_END(n) _ ## n ## SegmentRomEnd -// for x64 preprocess functions -#ifdef PLATFORM_64BIT -#define F(preprocessFunc) preprocessFunc##_x64 -#else -#define F(preprocessFunc) preprocessFunc -#endif - /* segment table for ntsc-final */ /* size will get calculated automatically if it is 0 */ /* if there are replacement files in the data dir, they will be loaded instead */ @@ -122,15 +115,15 @@ static struct romfile fileSlots[ROMDATA_MAX_FILES] = { ROMSEG_DECL_SEG(mpstringsS, 0x7e2f20, 0x7ce720, 0x7d25b0, 0x3700, NULL ) \ ROMSEG_DECL_SEG(mpstringsI, 0x7e6620, 0x7d1e20, 0x7d5cb0, 0x3700, NULL ) \ ROMSEG_DECL_SEG(firingrange, 0x7e9d20, 0x7d5520, 0x7d93b0, 0x1550, NULL ) \ - ROMSEG_DECL_SEG(fonttahoma, 0x7f7860, 0x7e3060, 0x7e6ef0, 0x0, F(preprocessFont) ) \ - ROMSEG_DECL_SEG(fontnumeric, 0x7f8b20, 0x7e4320, 0x7e81b0, 0x0, F(preprocessFont) ) \ - ROMSEG_DECL_SEG(fonthandelgothicsm, 0x7f9d30, 0x7e5530, 0x7e93c0, 0x0, F(preprocessFont) ) \ - ROMSEG_DECL_SEG(fonthandelgothicxs, 0x7fbfb0, 0x7e87b0, 0x7ec640, 0x0, F(preprocessFont) ) \ - ROMSEG_DECL_SEG(fonthandelgothicmd, 0x7fdd80, 0x7eae20, 0x7eecb0, 0x0, F(preprocessFont) ) \ - ROMSEG_DECL_SEG(fonthandelgothiclg, 0x8008e0, 0x7eee70, 0x7f2d00, 0x0, F(preprocessFont) ) \ - ROMSEG_DECL_SEG(sfxctl, 0x80a250, 0x7f87e0, 0x7fc670, 0x2fb80, F(preprocessALBankFile) ) \ + ROMSEG_DECL_SEG(fonttahoma, 0x7f7860, 0x7e3060, 0x7e6ef0, 0x0, preprocessFont ) \ + ROMSEG_DECL_SEG(fontnumeric, 0x7f8b20, 0x7e4320, 0x7e81b0, 0x0, preprocessFont ) \ + ROMSEG_DECL_SEG(fonthandelgothicsm, 0x7f9d30, 0x7e5530, 0x7e93c0, 0x0, preprocessFont ) \ + ROMSEG_DECL_SEG(fonthandelgothicxs, 0x7fbfb0, 0x7e87b0, 0x7ec640, 0x0, preprocessFont ) \ + ROMSEG_DECL_SEG(fonthandelgothicmd, 0x7fdd80, 0x7eae20, 0x7eecb0, 0x0, preprocessFont ) \ + ROMSEG_DECL_SEG(fonthandelgothiclg, 0x8008e0, 0x7eee70, 0x7f2d00, 0x0, preprocessFont ) \ + ROMSEG_DECL_SEG(sfxctl, 0x80a250, 0x7f87e0, 0x7fc670, 0x2fb80, preprocessALBankFile ) \ ROMSEG_DECL_SEG(sfxtbl, 0x839dd0, 0x828360, 0x82c1f0, 0x4c2160, NULL ) \ - ROMSEG_DECL_SEG(seqctl, 0xcfbf30, 0xcea4c0, 0xcee350, 0xa060, F(preprocessALBankFile) ) \ + ROMSEG_DECL_SEG(seqctl, 0xcfbf30, 0xcea4c0, 0xcee350, 0xa060, preprocessALBankFile ) \ ROMSEG_DECL_SEG(seqtbl, 0xd05f90, 0xcf4520, 0xcf83b0, 0x17c070, NULL ) \ ROMSEG_DECL_SEG(sequences, 0xe82000, 0xe70590, 0xe74420, 0x563a0, preprocessSequences ) \ ROMSEG_DECL_SEG(texturesdata, 0x1d65f40, 0x1d5ca20, 0x1d61f90, 0x0, NULL ) \ @@ -171,16 +164,14 @@ static struct romfile romSegs[] = { static preprocessfunc filePreprocFuncs[] = { /* LOADTYPE_NONE */ NULL, /* LOADTYPE_BG */ NULL, // loaded in parts - /* LOADTYPE_TILES */ F(preprocessTilesFile), - /* LOADTYPE_LANG */ F(preprocessLangFile), - /* LOADTYPE_SETUP */ F(preprocessSetupFile), - /* LOADTYPE_PADS */ F(preprocessPadsFile), - /* LOADTYPE_MODEL */ F(preprocessModelFile), - /* LOADTYPE_GUN */ F(preprocessModelFile), + /* LOADTYPE_TILES */ preprocessTilesFile, + /* LOADTYPE_LANG */ preprocessLangFile, + /* LOADTYPE_SETUP */ preprocessSetupFile, + /* LOADTYPE_PADS */ preprocessPadsFile, + /* LOADTYPE_MODEL */ preprocessModelFile, + /* LOADTYPE_GUN */ preprocessGunFile, }; -#undef F - static inline void romdataWrongRomError(const char *fmt, ...) { char reason[1024]; diff --git a/src/game/bg.c b/src/game/bg.c index af6ca5300..86c5011e0 100644 --- a/src/game/bg.c +++ b/src/game/bg.c @@ -2003,11 +2003,6 @@ void bgBuildTables(s32 stagenum) numlightsptr++; } -// in x64, lights are already pre-processed at this point (TEMP) -#if !defined(PLATFORM_N64) && !defined(PLATFORM_64BIT) - preprocessBgLights(g_BgLightsFileData, 0); -#endif - // Free the section 3 allocation mempRealloc(section3, 0, MEMPOOL_STAGE); diff --git a/src/game/lang.c b/src/game/lang.c index cd6ffc8c2..bd97e6c1f 100644 --- a/src/game/lang.c +++ b/src/game/lang.c @@ -425,11 +425,7 @@ char *langGet(s32 textid) uintptr_t addr; if (bank && bank[textindex]) { -#ifdef PLATFORM_64BIT addr = (uintptr_t)bank + bank[textindex]; -#else - addr = (uintptr_t)bank + PD_BE32(bank[textindex]); -#endif } else { addr = 0; } diff --git a/src/include/constants.h b/src/include/constants.h index ac33bf32c..1ddcb86e4 100644 --- a/src/include/constants.h +++ b/src/include/constants.h @@ -48,7 +48,6 @@ #define ABS(val) ((val) > 0 ? (val) : -(val)) #define ABSF(val) ((val) > 0.0f ? (val) : -(val)) -#define ALIGN(val, size) ((val + (size - 1)) & ~(size - 1)) #define ALIGN2(val) (((val) | 1) ^ 0x1) #define ALIGN4(val) (((val) | 3) ^ 0x3) #define ALIGN8(val) ((((val) + 0x7) | 0x7) ^ 0x7) diff --git a/src/lib/snd.c b/src/lib/snd.c index c2c88d694..558c068bb 100644 --- a/src/lib/snd.c +++ b/src/lib/snd.c @@ -1450,13 +1450,13 @@ void sndInit(void) #endif #if VERSION >= VERSION_JPN_FINAL - u32 heaplen = 1024 * 441; + u32 heaplen = 1024 * 528; #elif VERSION >= VERSION_PAL_BETA - u32 heaplen = 1024 * 446; + u32 heaplen = 1024 * 533; #elif VERSION >= VERSION_NTSC_1_0 - u32 heaplen = 1024 * 441; + u32 heaplen = 1024 * 528; #else - u32 heaplen = 1024 * 438; + u32 heaplen = 1024 * 525; #endif #ifdef PLATFORM_64BIT From 4d60c93bebae3d5a96dce2470c58e3d0cf6d02de Mon Sep 17 00:00:00 2001 From: Raf <> Date: Thu, 8 Aug 2024 20:54:59 +0800 Subject: [PATCH 33/81] portx64: romdata: proper estimated size for setup files, renamed getEstimatedFileSize function --- .gitignore | 1 + port/include/romdata.h | 2 +- port/src/romdata.c | 6 +++--- src/game/bg.c | 2 +- src/game/file.c | 2 +- 5 files changed, 7 insertions(+), 6 deletions(-) diff --git a/.gitignore b/.gitignore index 040d48862..c81aec73a 100644 --- a/.gitignore +++ b/.gitignore @@ -23,3 +23,4 @@ src/generated tools/mkrom/mkrom /.vs CppProperties.json +.idea diff --git a/port/include/romdata.h b/port/include/romdata.h index da0d81da0..6d604803f 100644 --- a/port/include/romdata.h +++ b/port/include/romdata.h @@ -30,6 +30,6 @@ s32 romdataFileGetNumForName(const char *name); u8 *romdataSegGetData(const char *segName); u8 *romdataSegGetDataEnd(const char *segName); u32 romdataSegGetSize(const char *segName); -u32 romdataGetEstimatedFileSize(u32 size, FileType filetype); +u32 romdataFileGetEstimatedSize(u32 size, FileType filetype); #endif diff --git a/port/src/romdata.c b/port/src/romdata.c index 515fff581..03b617b21 100644 --- a/port/src/romdata.c +++ b/port/src/romdata.c @@ -537,18 +537,18 @@ u32 romdataSegGetSize(const char *segName) return romdataGetSeg(segName)->size; } -u32 romdataGetEstimatedFileSize(u32 size, FileType filetype) +u32 romdataFileGetEstimatedSize(u32 size, FileType filetype) { #ifdef PLATFORM_64BIT switch (filetype) { case FT_BG: return (u32)(size * 1.1); case FT_TILES: return (u32)(size * 1.1); case FT_LANG: return (u32)(size * 1.3); - case FT_SETUP: return (u32)(size * 3.3); + case FT_SETUP: return (u32)(size * 1.5); case FT_PADS: return (u32)(size * 1.7); case FT_MODEL: return (u32)(size * 1.7); default: - sysLogPrintf(LOG_WARNING, "wrong file type in romdataGetEstimatedFileSize: %d", filetype); + sysLogPrintf(LOG_WARNING, "wrong file type in romdataFileGetEstimatedSize: %d", filetype); } #endif return size; diff --git a/src/game/bg.c b/src/game/bg.c index 86c5011e0..a3cd5047a 100644 --- a/src/game/bg.c +++ b/src/game/bg.c @@ -1511,7 +1511,7 @@ void bgReset(s32 stagenum) var8007fc54 -= 0xc; #ifdef PLATFORM_64BIT - inflatedsize = romdataGetEstimatedFileSize(inflatedsize, FT_BG); + inflatedsize = romdataFileGetEstimatedSize(inflatedsize, FT_BG); #endif inflatedsize = ALIGN16(inflatedsize); diff --git a/src/game/file.c b/src/game/file.c index 79ebd40ce..6c188338c 100644 --- a/src/game/file.c +++ b/src/game/file.c @@ -4283,7 +4283,7 @@ u32 fileGetInflatedSize(s32 filenum, FileType filetype) } if (rzipIs1173(ptr)) { - return romdataGetEstimatedFileSize((ptr[2] << 16) | (ptr[3] << 8) | ptr[4], filetype); + return romdataFileGetEstimatedSize((ptr[2] << 16) | (ptr[3] << 8) | ptr[4], filetype); } #if VERSION < VERSION_NTSC_1_0 From c519997b33d83efcb423633c37737ef9f7be2abf Mon Sep 17 00:00:00 2001 From: Raf <> Date: Thu, 8 Aug 2024 22:00:08 +0800 Subject: [PATCH 34/81] portx64: moved pdextract code to src/preprocess, renamed files and function names to follow the port standard --- port/src/preprocess/common.c | 33 + port/src/preprocess/common.h | 119 +++ port/src/preprocess/filebg.c | 651 +++++++++++++ port/src/preprocess/filelang.c | 95 ++ port/src/preprocess/filemodel.c | 1021 ++++++++++++++++++++ port/src/preprocess/filepads.c | 330 +++++++ port/src/preprocess/filesetup.c | 1202 ++++++++++++++++++++++++ port/src/preprocess/filetiles.c | 107 +++ port/src/{ => preprocess}/preprocess.c | 99 +- port/src/preprocess/segaudio.c | 426 +++++++++ port/src/preprocess/segfonts.c | 122 +++ port/src/preprocess/setups_decl.h | 642 +++++++++++++ port/src/preprocess/util_gbi.c | 209 ++++ 13 files changed, 4958 insertions(+), 98 deletions(-) create mode 100644 port/src/preprocess/common.c create mode 100644 port/src/preprocess/common.h create mode 100644 port/src/preprocess/filebg.c create mode 100644 port/src/preprocess/filelang.c create mode 100644 port/src/preprocess/filemodel.c create mode 100644 port/src/preprocess/filepads.c create mode 100644 port/src/preprocess/filesetup.c create mode 100644 port/src/preprocess/filetiles.c rename port/src/{ => preprocess}/preprocess.c (72%) create mode 100644 port/src/preprocess/segaudio.c create mode 100644 port/src/preprocess/segfonts.c create mode 100644 port/src/preprocess/setups_decl.h create mode 100644 port/src/preprocess/util_gbi.c diff --git a/port/src/preprocess/common.c b/port/src/preprocess/common.c new file mode 100644 index 000000000..542b9d8dc --- /dev/null +++ b/port/src/preprocess/common.c @@ -0,0 +1,33 @@ +#include "common.h" +#include "system.h" + +struct ptrmarker m_PtrMarkers[1024*8]; +int m_NumPtrMarkers; + +void addMarker(u32 ptr_src, uintptr_t ptr_host) +{ + if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { + sysLogPrintf(LOG_ERROR, "Marker limit exceeded"); + exit(EXIT_FAILURE); + } + + m_PtrMarkers[m_NumPtrMarkers].ptr_src = ptr_src; + m_PtrMarkers[m_NumPtrMarkers].ptr_host = ptr_host; + m_NumPtrMarkers++; +} + +struct ptrmarker* findPtrMarker(uintptr_t ptr_src) +{ + for (int i = 0; i < m_NumPtrMarkers; i++) { + if (m_PtrMarkers[i].ptr_src == ptr_src) { + return &m_PtrMarkers[i]; + } + } + + return NULL; +} + +void resetMarkers() +{ + m_NumPtrMarkers = 0; +} diff --git a/port/src/preprocess/common.h b/port/src/preprocess/common.h new file mode 100644 index 000000000..0f9930d94 --- /dev/null +++ b/port/src/preprocess/common.h @@ -0,0 +1,119 @@ +#ifndef _PDE_COMMON_H +#define _PDE_COMMON_H + +#include +#include +#include + +#include +// this BS comes from windows.h +#undef near +#undef far + +#include + +#include + +#include "types.h" +#include "constants.h" + + +#if __BIG_ENDIAN__ + #define htonll(x) (x) + #define ntohll(x) (x) +#else + #define htonll(x) ((((uint64_t)htonl(x&0xFFFFFFFF)) << 32) + htonl(x >> 32)) + #define ntohll(x) ((((uint64_t)ntohl(x&0xFFFFFFFF)) << 32) + ntohl(x >> 32)) +#endif + +#define htobe16(x) htons(x) +#define htole16(x) (x) +#define be16toh(x) ntohs(x) +#define le16toh(x) (x) + +#define htobe32(x) htonl(x) +#define htole32(x) (x) +#define be32toh(x) ntohl(x) +#define le32toh(x) (x) + +#define htobe64(x) htonll(x) +#define htole64(x) (x) +#define be64toh(x) ntohll(x) +#define le64toh(x) (x) + + +#define srctoh16(value) ntohs(value) +#define srctoh32(value) ntohl(value) +#define srctoh64(value) ntohll(value) + +#ifdef FORCE_BE32 +#define htodst16(value) htons(value) +#define htodst32(value) htonl(value) +#define htodst64(value) htonll(value) +#define dsttoh16(value) ntohs(value) +#define dsttoh32(value) ntohl(value) +#define dsttoh64(value) ntohll(value) +#else +#define htodst16(value) (value) +#define htodst32(value) (value) +#define htodst64(value) (value) +#define dsttoh16(value) (value) +#define dsttoh32(value) (value) +#define dsttoh64(value) (value) +#endif + +#define srctodst16(value) htodst16(srctoh16(value)) +#define srctodst32(value) htodst32(srctoh32(value)) +#define srctodst64(value) htodst64(srctoh64(value)) + +#ifdef FORCE_BE32 +#define uintptr_t u32 +#endif + +#define ALIGN(val, size) ((val + (size - 1)) & ~(size - 1)) + +#define PD_PTR_BASE(x, b) (void *)((u8 *)b + (uintptr_t)x) +#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (uintptr_t)x) + + +static inline f32 swapF32(f32 x) { *(u32*)&x = PD_BE32(*(u32*)&x); return x; } +static inline u32 swapU32(u32 x) { return PD_BE32(x); } +static inline s32 swapS32(s32 x) { return PD_BE32(x); } +static inline u16 swapU16(u16 x) { return PD_BE16(x); } +static inline s16 swapS16(s16 x) { return PD_BE16(x); } +static inline void* swapPtr(void** x) { return (void*)PD_BEPTR((uintptr_t)x); } +static inline struct coord swapCrd(struct coord crd) { crd.x = swapF32(crd.x); crd.y = swapF32(crd.y); crd.z = swapF32(crd.z); return crd; } +static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } + +#define PD_SWAP_VAL(x) x = _Generic((x), \ + f32: swapF32, \ + u32: swapU32, \ + s32: swapS32, \ + u16: swapU16, \ + s16: swapS16, \ + struct coord: swapCrd, \ + default: swapUnk \ +)(x) + +#define PD_SWAP_PTR(x) x = swapPtr((void *)(x)) + +// gbi related functions +void gbiReset(void); +void gbiSetSegment(int segment, u32 offset); +void gbiSetVtx(u32 src_offset, u32 dst_offset); +u32 gbiConvertGdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds); +void gbiConvertVtx(u8* dst, u32 dstpos, int count); +void gbiGdlRewriteAddrs(u8* dst, u32 offset); +void gbiAddTexAddr(u32 src_offset, u32 dst_offset); + +// ptr marker functions +struct ptrmarker { + u32 ptr_src; + uintptr_t ptr_host; +}; + +void addMarker(u32 ptr_src, uintptr_t ptr_host); +struct ptrmarker* findPtrMarker(uintptr_t ptr_src); +void resetMarkers(); + +#endif diff --git a/port/src/preprocess/filebg.c b/port/src/preprocess/filebg.c new file mode 100644 index 000000000..b592e1e18 --- /dev/null +++ b/port/src/preprocess/filebg.c @@ -0,0 +1,651 @@ +#include +#include +#include +#include + +#include "data.h" +#include "bss.h" +#include "platform.h" + +#include "common.h" +#include "system.h" + +int m_SizeGDLs; + +/** + * 4 bytes decompressed size of primary data + * 4 bytes compressed size of section 1 in its entirety + * 4 bytes compressed size of primary data + * Section 1: + * Primary: (zipped) + * 4 bytes null + * 4 bytes pointer to room table + * 4 bytes pointer to portal table + * 4 bytes pointer to bgcmds + * 4 bytes pointer to lights table + * 4 bytes null + * (room table) + * (portal table) + * (bgcmds) + * (lights table) + * room 1 (zipped) + * room 2 (zipped) + * ... + * Section 2: + * 2 bytes decompressed size of section (mask with 0x7fff) + * 2 bytes compressed size of section + * Texture ID list (zipped) + * Section 3: + * 2 bytes decompressed size of section (mask with 0x7fff) + * 2 bytes compressed size of section + * Zipped: + * (room bbox table) + * (list of roomgfxdata sizes) + * (list of light counts per room) + */ + +struct fileheader { + u32 primary_infsize; + u32 section1_cmpsize; + u32 primary_cmpsize; +}; + +struct sectionheader { + u16 infsize; + u16 cmpsize; +}; + +struct n64_primaryheader { + u32 unused1; + u32 ptr_rooms; + u32 ptr_portals; + u32 ptr_bgcmds; + u32 ptr_lights; + u32 unused2; +}; + +struct host_primaryheader { + uintptr_t unused1; + uintptr_t ptr_rooms; + uintptr_t ptr_portals; + uintptr_t ptr_bgcmds; + uintptr_t ptr_lights; + uintptr_t unused2; +}; + +struct n64_room { + u32 ptr_gfxdata; + u32 pos[3]; + u8 br_light_min; + u8 br_light_max; +}; + +struct host_room { + uintptr_t ptr_gfxdata; + u32 pos[3]; + u8 br_light_min; + u8 br_light_max; +}; + +struct portal { + u16 verticesoffset; + s16 roomnum1; + s16 roomnum2; + u8 flags; +}; + +struct generic_portalvertices { + u8 count; + u32 vertices[1][3]; +}; + +/* +struct light { + u16 roomnum; + u16 colour; + u8 brightness; + u8 sparkable : 1; + u8 healthy : 1; + u8 on : 1; + u8 sparking : 1; + u8 vulnerable : 1; + u8 brightnessmult; + s8 dirx; + s8 diry; + s8 dirz; + s16 bbox[4][3]; +};*/ + +struct n64_roomblock { + u8 type; + u32 ptr_next; + u32 ptr_gdl; + u32 ptr_vertices; + u32 ptr_colours; +}; + +struct host_roomblock { + u8 type; + uintptr_t ptr_next; + uintptr_t ptr_gdl; + uintptr_t ptr_vertices; + uintptr_t ptr_colours; +}; + +struct n64_roomgfxdata { + u32 ptr_vertices; + u32 ptr_colours; + u32 ptr_opablocks; + u32 ptr_xlublocks; + s16 lightsindex; + s16 numlights; + s16 numvertices; + s16 numcolours; + // roomblocks[] +}; + +struct host_roomgfxdata { + uintptr_t ptr_vertices; + uintptr_t ptr_colours; + uintptr_t ptr_opablocks; + uintptr_t ptr_xlublocks; + s16 lightsindex; + s16 numlights; + s16 numvertices; + s16 numcolours; + // roomblocks[] +}; + +struct vtx { + s16 coord[3]; + u8 flag; + u8 color; + u16 s; + u16 t; +}; + +int m_NumRooms; + +u32 m_AllocSizes[512]; + +static void convertPrimaryRooms(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) +{ + struct n64_room *n64_rooms = (struct n64_room *) &src[*srcpos]; + struct host_room *host_rooms = (struct host_room *) &dst[*dstpos]; + + m_NumRooms = 0; + + for (int i = 1; n64_rooms[i].ptr_gfxdata != 0; i++) { + m_NumRooms++; + } + + for (int i = 0; i < m_NumRooms + 1; i++) { + host_rooms[i].ptr_gfxdata = srctodst32(n64_rooms[i].ptr_gfxdata); + host_rooms[i].pos[0] = srctodst32(n64_rooms[i].pos[0]); + host_rooms[i].pos[1] = srctodst32(n64_rooms[i].pos[1]); + host_rooms[i].pos[2] = srctodst32(n64_rooms[i].pos[2]); + host_rooms[i].br_light_min = n64_rooms[i].br_light_min; + host_rooms[i].br_light_max = n64_rooms[i].br_light_max; + } + + *srcpos += sizeof(*n64_rooms) * (m_NumRooms + 2); + *dstpos += sizeof(*host_rooms) * (m_NumRooms +2); +} + +static void convertPrimaryPortals(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 *src_portalvtxs, u32 *dst_portalvtxs) +{ + struct portal *n64_portals = (struct portal *) &src[*srcpos]; + struct portal *host_portals = (struct portal *) &dst[*dstpos]; + + // Count portals + int numportals = 0; + + for (int i = 0; n64_portals[i].verticesoffset != 0; i++) { + numportals++; + } + + // Convert portals + for (int i = 0; i < numportals; i++) { + host_portals[i].verticesoffset = srctodst16(n64_portals[i].verticesoffset); + host_portals[i].roomnum1 = srctodst16(n64_portals[i].roomnum1); + host_portals[i].roomnum2 = srctodst16(n64_portals[i].roomnum2); + host_portals[i].flags = n64_portals[i].flags; + } + + *srcpos += sizeof(*n64_portals) * (numportals + 1); + *dstpos += sizeof(*host_portals) * (numportals + 1); + + *src_portalvtxs = *srcpos; + *dst_portalvtxs = *dstpos; + + while (1) { + struct generic_portalvertices *n64_pvertices = (struct generic_portalvertices*)&src[*srcpos]; + struct generic_portalvertices*host_pvertices = (struct generic_portalvertices*)&dst[*dstpos]; + + host_pvertices->count = n64_pvertices->count; + + for (int j = 0; j < host_pvertices->count; j++) { + //host_pvertices->vertices[j].x = srctodst32(n64_pvertices->vertices[j].x); + //host_pvertices->vertices[j].y = srctodst32(n64_pvertices->vertices[j].y); + //host_pvertices->vertices[j].z = srctodst32(n64_pvertices->vertices[j].z); + host_pvertices->vertices[j][0] = srctodst32(n64_pvertices->vertices[j][0]); + host_pvertices->vertices[j][1] = srctodst32(n64_pvertices->vertices[j][1]); + host_pvertices->vertices[j][2] = srctodst32(n64_pvertices->vertices[j][2]); + } + + *srcpos += 4 + host_pvertices->count * 12; + *dstpos += 4 + host_pvertices->count * 12; + + if (host_pvertices->count == 0) break; + } +} + +static void convertPrimaryBgCmds(u8 *dst, u32 *dstpos, u8 *src, u32 dst_portalvtxs, u32 src_portalvtxs) +{ + struct bgcmd *n64_cmds = (struct bgcmd *) src; + struct bgcmd *host_cmds = (struct bgcmd *) &dst[*dstpos]; + int num_cmds = 0; + + for (int i = 0; n64_cmds[i].type != 0; i++) { + num_cmds++; + } + + num_cmds++; + + for (int i = 0; i < num_cmds; i++) { + host_cmds[i].type = n64_cmds[i].type; + host_cmds[i].len = n64_cmds[i].len; + host_cmds[i].param = srctodst32(n64_cmds[i].param); + + if (host_cmds[i].type == 0x64) { + u32 offset = host_cmds[i].param - src_portalvtxs; + host_cmds[i].param = dst_portalvtxs + offset; + } + } + + *dstpos += sizeof(*host_cmds) * num_cmds; +} + +static void convertPrimaryLights(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 end) +{ + struct light *n64_lights = (struct light *) &src[*srcpos]; + struct light *host_lights = (struct light *) &dst[*dstpos]; + int num_lights = (end - *srcpos) / sizeof(struct light); + + for (int i = 0; i < num_lights; i++) { + host_lights[i].roomnum = srctodst16(n64_lights[i].roomnum); + host_lights[i].colour = srctodst16(n64_lights[i].colour); + host_lights[i].brightness = n64_lights[i].brightness; + host_lights[i].sparkable = n64_lights[i].sparkable; + host_lights[i].healthy = n64_lights[i].healthy; + host_lights[i].on = n64_lights[i].on; + host_lights[i].sparking = n64_lights[i].sparking; + host_lights[i].vulnerable = n64_lights[i].vulnerable; + host_lights[i].brightnessmult = n64_lights[i].brightnessmult; + host_lights[i].dirx = n64_lights[i].dirx; + host_lights[i].diry = n64_lights[i].diry; + host_lights[i].dirz = n64_lights[i].dirz; + + for (int j = 0; j < 4; j++) { + host_lights[i].bbox[j].x = srctodst16(n64_lights[i].bbox[j].x); + host_lights[i].bbox[j].y = srctodst16(n64_lights[i].bbox[j].y); + host_lights[i].bbox[j].z = srctodst16(n64_lights[i].bbox[j].z); + } + } + + *srcpos += sizeof(*n64_lights) * num_lights; + *dstpos += sizeof(*host_lights) * num_lights; +} + +#define BLOCK_LEAF 0 +#define BLOCK_PARENT 1 + +void relinkPtr(uintptr_t** ptr) +{ + if (!*ptr) return; + + struct ptrmarker* marker = findPtrMarker(*ptr); + if (!marker) { + fprintf(stderr, "[BG] WARNING: Unable to relink pointer: %p\n", ptr); + exit(EXIT_FAILURE); + } + + *ptr = marker->ptr_host; +} + +static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) +{ + resetMarkers(); + gbiReset(); + + u32 dst_roomoffset = src_ofs; + + uintptr_t gdls_addr[64]; + int numgdls = 0; + + struct n64_roomgfxdata *src_header = (struct n64_roomgfxdata*)src; + struct host_roomgfxdata *dst_header = (struct host_roomgfxdata*)dst; + + dst_header->ptr_vertices = srctoh32(src_header->ptr_vertices); + dst_header->ptr_colours = srctoh32(src_header->ptr_colours); + dst_header->ptr_opablocks = srctoh32(src_header->ptr_opablocks); + dst_header->ptr_xlublocks = srctoh32(src_header->ptr_xlublocks); + dst_header->lightsindex = srctoh16(src_header->lightsindex); + dst_header->numlights = srctoh16(src_header->numlights); + dst_header->numvertices = srctoh16(src_header->numvertices); + dst_header->numcolours = srctoh16(src_header->numcolours); + + intptr_t endpos = dst_header->ptr_vertices - src_ofs; + uintptr_t curpos_src = sizeof(struct n64_roomgfxdata); + uintptr_t curpos_dst = sizeof(struct host_roomgfxdata); + + // roomblocks + int ncoords = 0; + + // save the ptr to roomblocks here to iterate later to fix the pointers + struct host_roomblock *ptr_dst_roomblocks = (struct host_roomblock*)&dst[curpos_dst]; + + int numblocks = 0; + while ((intptr_t)(curpos_src + sizeof(struct n64_roomblock)) <= endpos) { + struct n64_roomblock *src_roomblock = (struct n64_roomblock*)&src[curpos_src]; + struct host_roomblock *dest_roomblock = (struct host_roomblock*)&dst[curpos_dst]; + + dest_roomblock->type = src_roomblock->type; + dest_roomblock->ptr_next = srctoh32(src_roomblock->ptr_next); + dest_roomblock->ptr_gdl = srctoh32(src_roomblock->ptr_gdl); + dest_roomblock->ptr_vertices = srctoh32(src_roomblock->ptr_vertices); + dest_roomblock->ptr_colours = srctoh32(src_roomblock->ptr_colours); + + addMarker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + + if (src_roomblock->type == BLOCK_PARENT) { + ncoords++; + uintptr_t vtx_ptr = dest_roomblock->ptr_vertices - src_ofs; + if (vtx_ptr < endpos) endpos = vtx_ptr; + } + else if (src_roomblock->ptr_gdl) { + gdls_addr[numgdls++] = srctoh32(src_roomblock->ptr_gdl) - src_ofs; + } + + curpos_src += sizeof(struct n64_roomblock); + curpos_dst += sizeof(struct host_roomblock); + numblocks++; + } + + // block coords + for (size_t i = 0; i < ncoords; i++) { + u32 *src_coord = (u32*)(src + curpos_src); + u32 *dst_coord = (u32*)(dst + curpos_dst); + + dst_coord[0] = srctoh32(src_coord[0]); + dst_coord[1] = srctoh32(src_coord[1]); + dst_coord[2] = srctoh32(src_coord[2]); + + dst_coord[3] = srctoh32(src_coord[3]); + dst_coord[4] = srctoh32(src_coord[4]); + dst_coord[5] = srctoh32(src_coord[5]); + + addMarker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + + curpos_src += 6 * sizeof(u32); + curpos_dst += 6 * sizeof(u32); + } + + curpos_dst = ALIGN8(curpos_dst); + + // vertices + uintptr_t ptr_src_vertices = curpos_src = ALIGN8(dst_header->ptr_vertices - src_ofs); + uintptr_t ptr_dst_vertices = curpos_dst + dst_roomoffset; + + addMarker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + + uintptr_t vtx_end = dst_header->ptr_colours - src_ofs; + + while (dst_header->ptr_colours && curpos_src < vtx_end) { + struct vtx *src_vtx = (struct vtx*)(src + curpos_src); + struct vtx *dst_vtx = (struct vtx*)(dst + curpos_dst); + + dst_vtx->coord[0] = srctoh16(src_vtx->coord[0]); + dst_vtx->coord[1] = srctoh16(src_vtx->coord[1]); + dst_vtx->coord[2] = srctoh16(src_vtx->coord[2]); + + dst_vtx->flag = src_vtx->flag; + dst_vtx->color = src_vtx->color; + + dst_vtx->s = srctoh16(src_vtx->s); + dst_vtx->t = srctoh16(src_vtx->t); + + curpos_src += sizeof(struct vtx); + curpos_dst += sizeof(struct vtx); + } + + curpos_dst = ALIGN8(curpos_dst); + + // colors + uintptr_t ptr_src_colors = 0; + uintptr_t ptr_dst_colors = 0; + + if (dst_header->ptr_colours) { + ptr_src_colors = curpos_src = ALIGN8(dst_header->ptr_colours - src_ofs); + ptr_dst_colors = curpos_dst + dst_roomoffset; + + addMarker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + + uintptr_t col_end = numgdls > 0 != 0 ? gdls_addr[0] : infsize; + size_t col_len = col_end - curpos_src; + + memcpy(dst + curpos_dst, src + curpos_src, col_len); + curpos_src += col_len; + curpos_dst += col_len; + } + + // gdls + gbiSetVtx(src_header->ptr_vertices, ptr_src_vertices); + gbiSetSegment(0x0e, dst_header->ptr_vertices); + + m_SizeGDLs = 0; + uintptr_t gdlstart = curpos_dst; + for (size_t i = 0; i < numgdls; i++) { + addMarker(gdls_addr[i] + src_ofs, curpos_dst + dst_roomoffset); + curpos_dst = gbiConvertGdl(dst, curpos_dst, src, gdls_addr[i], 1); + } + m_SizeGDLs = curpos_dst - gdlstart; + + // relink ptrs: roomblocks + for (size_t i = 0; i < numblocks; i++) { + struct host_roomblock *block = (struct host_roomblock*)&ptr_dst_roomblocks[i]; + + relinkPtr(&block->ptr_next); + + if (block->type == BLOCK_LEAF) { + relinkPtr(&block->ptr_gdl); + u32 offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; + u32 offset_col = block->ptr_colours - ptr_src_colors - src_ofs; + + block->ptr_vertices = ptr_dst_vertices + offset_vtx; + block->ptr_colours = ptr_dst_colors + offset_col; + } + else { + relinkPtr(&block->ptr_gdl); // child + relinkPtr(&block->ptr_vertices); // coord + } + } + + // relink ptrs: header + relinkPtr(&dst_header->ptr_vertices); + relinkPtr(&dst_header->ptr_colours); + relinkPtr(&dst_header->ptr_opablocks); + relinkPtr(&dst_header->ptr_xlublocks); + + return curpos_dst; +} + +static u32 convertSection1(u8 *dst, u8 *src, u32 ofs) +{ + // Convert primary + u32 srcpos = 0; + u32 dstpos = 0; + struct host_primaryheader *host_primary_header = (struct host_primaryheader *) dst; + struct n64_primaryheader *n64_primary_header = (struct n64_primaryheader *) src; + srcpos += sizeof(struct n64_primaryheader); + dstpos += sizeof(*host_primary_header); + + u32 src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - ofs; + + host_primary_header->unused1 = 0; + host_primary_header->unused2 = 0; + + host_primary_header->ptr_rooms = dstpos + ofs; + convertPrimaryRooms(dst, &dstpos, src, &srcpos); + + if (n64_primary_header->ptr_lights) { + host_primary_header->ptr_lights = dstpos + ofs; + srcpos = srctodst32(n64_primary_header->ptr_lights) - ofs; + convertPrimaryLights(dst, &dstpos, src, &srcpos, src_bgcmds); + } + + host_primary_header->ptr_portals = dstpos + ofs; + srcpos = srctodst32(n64_primary_header->ptr_portals) - ofs; + u32 src_portalvtxs, dst_portalvtxs; + convertPrimaryPortals(dst, &dstpos, src, &srcpos, &src_portalvtxs, &dst_portalvtxs); + + host_primary_header->ptr_bgcmds = dstpos + ofs; + convertPrimaryBgCmds(dst, &dstpos, &src[src_bgcmds], dst_portalvtxs, src_portalvtxs); + + return dstpos; +} + +static void convert_section2_texturenums(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 srclen) +{ + u16 *src_ids = (u16 *) &src[*srcpos]; + u16 *dst_ids = (u16 *) &dst[*dstpos]; + int count = srclen / sizeof(u16); + + for (int i = 0; i < count; i++) { + dst_ids[i] = srctodst16(src_ids[i]); + } + + *srcpos += srclen; + *dstpos += srclen; +} + +static void convert_section3_bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) +{ + s16 *src_bboxes = (s16 *) &src[*srcpos]; + s16 *dst_bboxes = (s16 *) &dst[*dstpos]; + + for (int i = 0; i < m_NumRooms; i++) { + dst_bboxes[i * 6 + 0] = srctodst16(src_bboxes[i * 6 + 0]); + dst_bboxes[i * 6 + 1] = srctodst16(src_bboxes[i * 6 + 1]); + dst_bboxes[i * 6 + 2] = srctodst16(src_bboxes[i * 6 + 2]); + dst_bboxes[i * 6 + 3] = srctodst16(src_bboxes[i * 6 + 3]); + dst_bboxes[i * 6 + 4] = srctodst16(src_bboxes[i * 6 + 4]); + dst_bboxes[i * 6 + 5] = srctodst16(src_bboxes[i * 6 + 5]); + } + + *srcpos += sizeof(s16) * 6 * (m_NumRooms - 1); + *dstpos += sizeof(s16) * 6 * (m_NumRooms - 1); +} + +static void convert_section3_allocsizes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) +{ + u16 *dst_sizes = (u16 *) &dst[*dstpos]; + + for (int i = 0; i < m_NumRooms; i++) { + dst_sizes[i] = (m_AllocSizes[i] - 0x100) / 0x10; + } + + *srcpos += sizeof(u16) * (m_NumRooms - 1); + *dstpos += sizeof(u16) * (m_NumRooms - 1); +} + +static void convert_section3_lightcounts(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) +{ + memcpy(&dst[*dstpos], &src[*srcpos], m_NumRooms); + + *srcpos += (m_NumRooms - 1); + *dstpos += (m_NumRooms - 1); +} + +void preprocessBgSection1(u8 *data, u32 size, u32 ofs) +{ + u8 *dst = sysMemZeroAlloc(size); + + u32 newSize = convertSection1(dst, data, ofs); + + if (newSize > size) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg file, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); +} + +u32 preprocessBgRoom(u8 *data, u32 size, u32 room_ofs) +{ + size *= 2; + u8 *dst = sysMemZeroAlloc(size); + u32 newSize = convertRoomGfxData(dst, data, size, room_ofs); + + if (newSize > size) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg room, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); + + return newSize; +} + +void preprocessBgSection1Header(u8* data, u32 size) +{ + u32* header = (u32*)data; + PD_SWAP_VAL(header[0]); // inflatedsize + PD_SWAP_VAL(header[1]); // section1size + PD_SWAP_VAL(header[2]); // primcompsize +} + +void preprocessBgSection2Header(u8* data, u32 size) +{ + u16* header = (u16*)data; + PD_SWAP_VAL(header[0]); // inflatedsize + PD_SWAP_VAL(header[1]); // section2compsize +} + +void preprocessBgSection2(u8* data, u32 size) +{ + // section2 is a texture id list + u16* section2 = (u16*)data; + for (s32 i = 0; i < size; ++i) { + PD_SWAP_VAL(section2[i]); + } +} + +void preprocessBgSection3Header(u8* data, u32 size) +{ + u16* header = (u16*)data; + PD_SWAP_VAL(header[0]); + PD_SWAP_VAL(header[1]); +} + +void preprocessBgSection3(u8* data, u32 size) +{ + // room bounding boxes, 6x s16 per room + s16* bbox = (s16*)data; + for (s32 i = 1; i < g_Vars.roomcount; ++i) { + PD_SWAP_VAL(*bbox); ++bbox; + PD_SWAP_VAL(*bbox); ++bbox; + PD_SWAP_VAL(*bbox); ++bbox; + PD_SWAP_VAL(*bbox); ++bbox; + PD_SWAP_VAL(*bbox); ++bbox; + PD_SWAP_VAL(*bbox); ++bbox; + } + + // gfxdatalen list + u16* gfxdatalen = (u16*)bbox; + for (s32 i = 1; i < g_Vars.roomcount; ++i) { + PD_SWAP_VAL(*gfxdatalen); ++gfxdatalen; + } +} diff --git a/port/src/preprocess/filelang.c b/port/src/preprocess/filelang.c new file mode 100644 index 000000000..46abe902c --- /dev/null +++ b/port/src/preprocess/filelang.c @@ -0,0 +1,95 @@ +#include +#include +#include + +#include "common.h" +#include "romdata.h" +#include "system.h" + +static int getNextNonZero(u8 *src, u32 offset, size_t len) +{ + u32 *ptr = (u32 *) &src[offset]; + u32 *end = (u32 *) &src[len]; + + while (ptr < end) { + if (*ptr != 0) { + return srctoh32(*ptr); + } + + ptr++; + } + + return 0; +} + +static int getNumStrings(u8 *src, size_t len) +{ + u32 ptr_table_len = getNextNonZero(src, 0, len); + + if (ptr_table_len) { + return ptr_table_len / sizeof(u32); + } + + return 1; +} + +u32 convertLangFile(u8 *dst, u8 *src, size_t srclen) +{ + // Convert it + u32 *src_offsets = (u32 *) src; + size_t src_ptr_table_len = srctoh32(src_offsets[0]); + size_t src_str_table_len = srclen - src_ptr_table_len; + int num_strings = getNumStrings(src, srclen); + size_t dst_ptr_table_len = num_strings * sizeof(uintptr_t); + size_t dst_str_table_len = src_str_table_len; + + int cur_dst_offset = dst_ptr_table_len; + + uintptr_t *dst_offsets = (uintptr_t *) dst; + + for (int i = 0; i < num_strings; i++) { + u32 src_offset = srctoh32(src_offsets[i]); + + if (src_offset) { + // Write pointer + dst_offsets[i] = htodst32(cur_dst_offset); + + // Write string + u32 end = getNextNonZero(src, (i + 1) * 4, num_strings * 4); + + if (!end) { + end = srclen; + } + + size_t len = end - src_offset; + len = ALIGN4(len); + memcpy(&dst[cur_dst_offset], &src[src_offset], len); + + cur_dst_offset += len; + } else { + // Write pointer + dst_offsets[i] = 0; + } + } + + return ALIGN16(cur_dst_offset); +} + +u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize) { + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_LANG); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); + + u32 newSize = convertLangFile(dst, data, size); + + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a lang file, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); + + *outSize = newSize; + + return 0; +} diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c new file mode 100644 index 000000000..5edece56e --- /dev/null +++ b/port/src/preprocess/filemodel.c @@ -0,0 +1,1021 @@ +#include +#include +#include + +#include "types.h" +#include "gbi.h" +#include "game/texdecompress.h" + +#include "common.h" +#include "romdata.h" +#include "system.h" + +enum contenttype { + /* 0*/ CT_MODELDEF, + /* 1*/ CT_NODE, + /* 2*/ CT_TEXCONFIG, + /* 3*/ CT_TEXDATA, + /* 4*/ CT_PARTS, + /* 5*/ CT_VTXCOL, + /* 6*/ CT_GDL, + /* 7*/ CT_RODATA_CHRINFO, + /* 8*/ CT_RODATA_POSITION, + /* 9*/ CT_RODATA_GUNDL, + /*10*/ CT_RODATA_DISTANCE, + /*11*/ CT_RODATA_REORDER, + /*12*/ CT_RODATA_BBOX, + /*13*/ CT_RODATA_CHRGUNFIRE, + /*14*/ CT_RODATA_11, + /*15*/ CT_RODATA_TOGGLE, + /*16*/ CT_RODATA_POSITIONHELD, + /*17*/ CT_RODATA_STARGUNFIRE, + /*18*/ CT_RODATA_HEADSPOT, + /*19*/ CT_RODATA_DL, + /*20*/ CT_RODATA_19, + /*21*/ CT_VTXCOL4, // CT_VTXCOL but aligned to 4 bytes instead of 8 +}; + +struct marker { + u32 src_offset; + u32 dst_offset; + u32 parent_src_offset; + enum contenttype type; +}; + +struct alignconfig { + int before; + int after; +}; + +struct alignconfig m_AlignConfigs[] = { + /* 0*/ { 16, 4 }, + /* 1*/ { 4, 4 }, + /* 2*/ { 4, 4 }, + /* 3*/ { 8, 8 }, // CT_TEXDATA + /* 4*/ { 4, 4 }, + /* 5*/ { 8, 4 }, // CT_VTXCOL + /* 6*/ { 8, 8 }, // CT_GDL + /* 7*/ { 4, 4 }, + /* 8*/ { 4, 4 }, + /* 9*/ { 8, 4 }, // CT_GUNDL + /*10*/ { 4, 4 }, + /*11*/ { 4, 4 }, + /*12*/ { 4, 4 }, + /*13*/ { 4, 4 }, + /*14*/ { 4, 4 }, + /*15*/ { 4, 4 }, + /*16*/ { 4, 4 }, + /*17*/ { 8, 4 }, // CT_STARGUNFIRE + /*18*/ { 4, 4 }, + /*19*/ { 8, 4 }, // CT_RODATA_DL + /*20*/ { 4, 4 }, + /*21*/ { 4, 4 }, +}; + +struct marker m_Markers[1024]; +int m_NumMarkers; + +struct src_modeldef { + u32 ptr_rootnode; + u32 ptr_skel; + u32 ptr_parts; + s16 numparts; + s16 nummatrices; + u32 scale; + u16 rwdatalen; + u16 numtexconfigs; + u32 ptr_texconfigs; +}; + +struct dst_modeldef { + uintptr_t ptr_rootnode; + uintptr_t ptr_skel; + uintptr_t ptr_parts; + s16 numparts; + s16 nummatrices; + u32 scale; + u16 rwdatalen; + u16 numtexconfigs; + uintptr_t ptr_texconfigs; +}; + +struct src_modelnode { + u16 type; + u32 ptr_rodata; + u32 ptr_parent; + u32 ptr_next; + u32 ptr_prev; + u32 ptr_child; +}; + +struct dst_modelnode { + u16 type; + uintptr_t ptr_rodata; + uintptr_t ptr_parent; + uintptr_t ptr_next; + uintptr_t ptr_prev; + uintptr_t ptr_child; +}; + +struct generic_rodata_chrinfo { + u16 animpart; + s16 mtxindex; + u32 unk04; + u16 rwdataindex; +}; + +struct generic_rodata_position { + u32 pos[3]; + u16 part; + s16 mtxindexes[3]; + u32 drawdist; +}; + +struct src_rodata_gundl { + u32 ptr_opagdl; + u32 ptr_xlugdl; + u32 ptr_baseaddr; + u32 ptr_vertices; + s16 numvertices; + s16 unk12; +}; + +struct dst_rodata_gundl { + uintptr_t ptr_opagdl; + uintptr_t ptr_xlugdl; + uintptr_t ptr_baseaddr; + uintptr_t ptr_vertices; + s16 numvertices; + s16 unk12; +}; + +struct src_rodata_distance { + u32 near; + u32 far; + u32 ptr_target; + u16 rwdataindex; +}; + +struct dst_rodata_distance { + u32 near; + u32 far; + uintptr_t ptr_target; + u16 rwdataindex; +}; + +struct src_rodata_reorder { + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c[3]; + u32 ptr_node_unk18; + u32 ptr_node_unk1c; + s16 side; + u16 rwdataindex; +}; + +struct dst_rodata_reorder { + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c[3]; + uintptr_t ptr_node_unk18; + uintptr_t ptr_node_unk1c; + s16 side; + u16 rwdataindex; +}; + +struct generic_rodata_bbox { + s32 hitpart; + u32 bbox[6]; +}; + +struct src_rodata_chrgunfire { + u32 pos[3]; + u32 dim[3]; + u32 ptr_texture; + u32 unk1c; + u16 rwdataindex; + u32 ptr_baseaddr; +}; + +struct dst_rodata_chrgunfire { + u32 pos[3]; + u32 dim[3]; + uintptr_t ptr_texture; + u32 unk1c; + u16 rwdataindex; + uintptr_t ptr_baseaddr; +}; + +struct src_rodata_type11 { + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c; + u32 unk10; + u32 ptr_unk14; // not used + u32 extra1; + u32 extra2; +}; + +struct dst_rodata_type11 { + u32 unk00; + u32 unk04; + u32 unk08; + u32 unk0c; + u32 unk10; + u32 unk14; + u32 extra1; + u32 extra2; +}; + +struct src_rodata_toggle { + u32 ptr_target; + u16 rwdataindex; +}; + +struct dst_rodata_toggle { + uintptr_t ptr_target; + u16 rwdataindex; +}; + +struct generic_rodata_positionheld { + u32 pos[3]; + s16 mtxindex; + u32 unk10; +}; + +struct src_rodata_stargunfire { + u32 unk00; + u32 ptr_vertices; + u32 ptr_gdl; + u32 ptr_baseaddr; +}; + +struct dst_rodata_stargunfire { + u32 unk00; + uintptr_t ptr_vertices; + uintptr_t ptr_gdl; + uintptr_t ptr_baseaddr; +}; + +struct generic_rodata_headspot { + u16 rwdataindex; +}; + +struct src_rodata_dl { + u32 ptr_opagdl; + u32 ptr_xlugdl; + u32 ptr_colours; + u32 ptr_vertices; // colours follow this array + s16 numvertices; + s16 mcount; + u16 rwdataindex; + u16 numcolours; +}; + +struct dst_rodata_dl { + uintptr_t ptr_opagdl; + uintptr_t ptr_xlugdl; + uintptr_t ptr_colours; + uintptr_t ptr_vertices; // colours follow this array + s16 numvertices; + s16 mcount; + u16 rwdataindex; + u16 numcolours; +}; + +struct generic_rodata_type19 { + u32 numvertices; + u32 vertices[3]; +}; + +struct src_texconfig { + u32 ptr; + u8 width; + u8 height; + u8 level; + u8 format; + u8 depth; + u8 s; + u8 t; + u8 unk0b; +}; + +struct dst_texconfig { + uintptr_t ptr; + u8 width; + u8 height; + u8 level; + u8 format; + u8 depth; + u8 s; + u8 t; + u8 unk0b; +}; + +static inline void *minPtr(void *a, void *b) { + return (a && (a < b || !b)) ? a : b; +} + +static inline void *minPtr3(void *a, void *b, void *c) { + return minPtr(minPtr(a, b), c); +} + +static struct marker *find_marker(u32 src_offset) +{ + for (int i = 0; i < m_NumMarkers; i++) { + if (m_Markers[i].src_offset == src_offset) { + return &m_Markers[i]; + } + } + + return NULL; +} + +static void set_marker(u32 src_offset, enum contenttype type, u32 parent_src_offset) +{ + if (src_offset == 0) { + return; + } + + src_offset &= 0x00ffffff; + + if (find_marker(src_offset)) { + return; + } + + if (m_NumMarkers >= ARRAYCOUNT(m_Markers)) { + fprintf(stderr, "Marker limit exceeded\n"); + exit(EXIT_FAILURE); + } + + m_Markers[m_NumMarkers].src_offset = src_offset; + m_Markers[m_NumMarkers].type = type; + m_Markers[m_NumMarkers].parent_src_offset = parent_src_offset; + m_NumMarkers++; +} + +enum contenttype m_NodeTypeToContentType[] = { + /*0x00*/ -1, + /*0x01*/ CT_RODATA_CHRINFO, + /*0x02*/ CT_RODATA_POSITION, + /*0x03*/ -1, + /*0x04*/ CT_RODATA_GUNDL, + /*0x05*/ -1, + /*0x06*/ -1, + /*0x07*/ -1, + /*0x08*/ CT_RODATA_DISTANCE, + /*0x09*/ CT_RODATA_REORDER, + /*0x0a*/ CT_RODATA_BBOX, + /*0x0b*/ -1, + /*0x0c*/ CT_RODATA_CHRGUNFIRE, + /*0x0d*/ -1, + /*0x0e*/ -1, + /*0x0f*/ -1, + /*0x10*/ -1, + /*0x11*/ CT_RODATA_11, + /*0x12*/ CT_RODATA_TOGGLE, + /*0x13*/ -1, + /*0x14*/ -1, + /*0x15*/ CT_RODATA_POSITIONHELD, + /*0x16*/ CT_RODATA_STARGUNFIRE, + /*0x17*/ CT_RODATA_HEADSPOT, + /*0x18*/ CT_RODATA_DL, + /*0x19*/ CT_RODATA_19, +}; + +static void populateMarkers(u8 *src) +{ + m_NumMarkers = 0; + + set_marker(0x05000000, CT_MODELDEF, 0); + + for (int i = 0; i < m_NumMarkers; i++) { + struct marker *marker = &m_Markers[i]; + void *src_thing = &src[marker->src_offset]; + int numvtx = 0; + u32 colstart = 0; + + switch (marker->type) { + case CT_MODELDEF: + struct src_modeldef *src_modeldef = src_thing; + int num_texconfigs = srctoh16(src_modeldef->numtexconfigs); + u32 texconfigpos = srctoh32(src_modeldef->ptr_texconfigs); + set_marker(srctoh32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); + + for (int i = 0; i < num_texconfigs; i++) { + set_marker(texconfigpos + sizeof(struct src_texconfig) * i, CT_TEXCONFIG, marker->src_offset); + } + break; + case CT_NODE: + struct src_modelnode *src_node = src_thing; + u32 node_type = srctoh16(src_node->type) & 0xff; + set_marker(srctoh32(src_node->ptr_rodata), m_NodeTypeToContentType[node_type], marker->src_offset); + set_marker(srctoh32(src_node->ptr_parent), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_node->ptr_next), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_node->ptr_prev), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_node->ptr_child), CT_NODE, marker->src_offset); + break; + case CT_TEXCONFIG: + struct src_texconfig *src_texconfig = src_thing; + if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { + set_marker(srctoh32(src_texconfig->ptr), CT_TEXDATA, marker->src_offset); + } + break; + case CT_PARTS: + struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + u32 *src_parts = (u32 *) src_thing; + int num_parts = srctoh16(src_modeldef2->numparts); + + for (int i = 0; i < num_parts; i++) { + set_marker(srctoh32(src_parts[i]), CT_NODE, marker->src_offset); + } + break; + case CT_RODATA_CHRINFO: + break; + case CT_RODATA_POSITION: + break; + case CT_RODATA_GUNDL: + struct src_rodata_gundl *src_gundl = src_thing; + set_marker(srctoh32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); + set_marker(srctoh32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); + set_marker(srctoh32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); + break; + case CT_RODATA_DISTANCE: + struct src_rodata_distance *src_dist = src_thing; + set_marker(srctoh32(src_dist->ptr_target), CT_NODE, marker->src_offset); + break; + case CT_RODATA_REORDER: + struct src_rodata_reorder *src_reorder = src_thing; + set_marker(srctoh32(src_reorder->ptr_node_unk18), CT_NODE, marker->src_offset); + set_marker(srctoh32(src_reorder->ptr_node_unk1c), CT_NODE, marker->src_offset); + break; + case CT_RODATA_CHRGUNFIRE: + struct src_rodata_chrgunfire *src_chrgunfire = src_thing; + set_marker(srctoh32(src_chrgunfire->ptr_texture), CT_TEXCONFIG, marker->src_offset); + break; + case CT_RODATA_TOGGLE: + struct src_rodata_toggle *src_toggle = src_thing; + set_marker(srctoh32(src_toggle->ptr_target), CT_NODE, marker->src_offset); + break; + case CT_RODATA_STARGUNFIRE: + struct src_rodata_stargunfire *src_stargunfire = src_thing; + colstart = srctoh32(src_stargunfire->unk00)*4*12; + u32 vtxstart = srctoh32(src_stargunfire->ptr_vertices); + colstart = ALIGN(vtxstart + colstart, 8); + + set_marker(srctoh32(src_stargunfire->ptr_vertices), CT_VTXCOL4, marker->src_offset); + set_marker(colstart, CT_VTXCOL4, marker->src_offset); + set_marker(srctoh32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); + break; + case CT_RODATA_DL: + struct src_rodata_dl *src_dl = src_thing; + set_marker(srctoh32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); + set_marker(srctoh32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); + set_marker(srctoh32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); + set_marker(srctoh32(src_dl->ptr_vertices), CT_VTXCOL, marker->src_offset); + break; + case CT_TEXDATA: + case CT_VTXCOL: + case CT_GDL: + case CT_RODATA_BBOX: + case CT_RODATA_11: + case CT_RODATA_POSITIONHELD: + case CT_RODATA_HEADSPOT: + case CT_RODATA_19: + break; + } + } +} + +static void sortMarkers(void) +{ + for (int i = 0; i < m_NumMarkers - 1; i++) { + u32 min_offset = 0xffffffff; + int min_index = -1; + + for (int j = i + 1; j < m_NumMarkers; j++) { + if (m_Markers[j].src_offset < min_offset) { + min_offset = m_Markers[j].src_offset; + min_index = j; + } + } + + if (min_index >= 0 && m_Markers[min_index].src_offset < m_Markers[i].src_offset) { + struct marker tmp = m_Markers[i]; + m_Markers[i] = m_Markers[min_index]; + m_Markers[min_index] = tmp; + } + } +} + +static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) +{ + u32 dstpos = 0; + + for (int i = 0; i < m_NumMarkers; i++) { + struct marker *marker = &m_Markers[i]; + void *src_thing = &src[marker->src_offset]; + u32 src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; + u32 src_len = src_end - marker->src_offset; + + dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].before); + + marker->dst_offset = dstpos; + void *dst_thing = &dst[dstpos]; + + switch (marker->type) { + case CT_MODELDEF: + struct src_modeldef *src_modeldef = src_thing; + struct dst_modeldef *dst_modeldef = dst_thing; + dst_modeldef->ptr_skel = srctodst32(src_modeldef->ptr_skel); + dst_modeldef->numparts = srctodst16(src_modeldef->numparts); + dst_modeldef->nummatrices = srctodst16(src_modeldef->nummatrices); + dst_modeldef->scale = srctodst32(src_modeldef->scale); + dst_modeldef->rwdatalen = srctodst16(src_modeldef->rwdatalen); + dst_modeldef->numtexconfigs = srctodst16(src_modeldef->numtexconfigs); + dstpos += sizeof(*dst_modeldef); + break; + case CT_NODE: + struct src_modelnode *src_node = src_thing; + struct dst_modelnode *dst_node = dst_thing; + dst_node->type = srctodst16(src_node->type); + dstpos += sizeof(*dst_node); + break; + case CT_TEXCONFIG: + struct src_texconfig *src_texconfig = src_thing; + struct dst_texconfig *dst_texconfig = dst_thing; + + while (src_len >= sizeof(*src_texconfig)) { + if ((srctoh32(src_texconfig->ptr) & 0xff000000) != 0x05000000) { + dst_texconfig->ptr = srctodst32(src_texconfig->ptr); + } + + dst_texconfig->width = src_texconfig->width; + dst_texconfig->height = src_texconfig->height; + dst_texconfig->level = src_texconfig->level; + dst_texconfig->format = src_texconfig->format; + dst_texconfig->depth = src_texconfig->depth; + dst_texconfig->s = src_texconfig->s; + dst_texconfig->t = src_texconfig->t; + dst_texconfig->unk0b = src_texconfig->unk0b; + + dstpos += sizeof(*dst_texconfig); + src_len -= sizeof(*src_texconfig); + src_texconfig++; + dst_texconfig++; + } + break; + case CT_TEXDATA: + memcpy(dst_thing, src_thing, src_len); + dstpos += src_len; + break; + case CT_PARTS: + struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + u32 *src_parts = (u32 *) src_thing; + uintptr_t *dst_parts = (uintptr_t *) dst_thing; + int num_parts = srctoh16(src_modeldef2->numparts); + u16 *src_nums = (u16 *) &src_parts[num_parts]; + u16 *dst_nums = (u16 *) &dst_parts[num_parts]; + + for (int i = 0; i < num_parts; i++) { + dst_nums[i] = srctodst16(src_nums[i]); + } + dstpos += num_parts * sizeof(uintptr_t) + num_parts * sizeof(u16); + if (num_parts) { + dstpos = ALIGN8(dstpos); + } + break; + case CT_VTXCOL: + case CT_VTXCOL4: + memcpy(dst_thing, src_thing, src_len); + dstpos += src_len; + break; + case CT_GDL: + struct marker *parent = find_marker(marker->parent_src_offset); + u32 src_vtx; + u32 dst_vtx; + + if (parent->type == CT_RODATA_GUNDL) { + struct src_rodata_gundl *src_rodata = (struct src_rodata_gundl *) &src[parent->src_offset]; + struct dst_rodata_gundl *dst_rodata = (struct dst_rodata_gundl *) &dst[parent->dst_offset]; + src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + } else if (parent->type == CT_RODATA_STARGUNFIRE) { + struct src_rodata_stargunfire *src_rodata = (struct src_rodata_stargunfire *) &src[parent->src_offset]; + struct dst_rodata_stargunfire *dst_rodata = (struct dst_rodata_stargunfire *) &dst[parent->dst_offset]; + src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + } else if (parent->type == CT_RODATA_DL) { + struct src_rodata_dl *src_rodata = (struct src_rodata_dl *) &src[parent->src_offset]; + struct dst_rodata_dl *dst_rodata = (struct dst_rodata_dl *) &dst[parent->dst_offset]; + src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + } + + dstpos = gbiConvertGdl(dst, dstpos, src, marker->src_offset, 0); + break; + case CT_RODATA_CHRINFO: + struct generic_rodata_chrinfo *src_chrinfo = src_thing; + struct generic_rodata_chrinfo *dst_chrinfo = dst_thing; + dst_chrinfo->animpart = srctodst16(src_chrinfo->animpart); + dst_chrinfo->mtxindex = srctodst16(src_chrinfo->mtxindex); + dst_chrinfo->unk04 = srctodst32(src_chrinfo->unk04); + dst_chrinfo->rwdataindex = srctodst16(src_chrinfo->rwdataindex); + dstpos += sizeof(*dst_chrinfo); + break; + case CT_RODATA_POSITION: + struct generic_rodata_position *src_position = src_thing; + struct generic_rodata_position *dst_position = dst_thing; + dst_position->pos[0] = srctodst32(src_position->pos[0]); + dst_position->pos[1] = srctodst32(src_position->pos[1]); + dst_position->pos[2] = srctodst32(src_position->pos[2]); + dst_position->part = srctodst16(src_position->part); + dst_position->mtxindexes[0] = srctodst16(src_position->mtxindexes[0]); + dst_position->mtxindexes[1] = srctodst16(src_position->mtxindexes[1]); + dst_position->mtxindexes[2] = srctodst16(src_position->mtxindexes[2]); + dst_position->drawdist = srctodst32(src_position->drawdist); + dstpos += sizeof(*dst_position); + break; + case CT_RODATA_GUNDL: + struct src_rodata_gundl *src_gundl = src_thing; + struct dst_rodata_gundl *dst_gundl = dst_thing; + dst_gundl->ptr_vertices = 0; + dst_gundl->numvertices = srctodst16(src_gundl->numvertices); + dst_gundl->unk12 = srctodst16(src_gundl->unk12); + dstpos += sizeof(*dst_gundl); + break; + case CT_RODATA_DISTANCE: + struct src_rodata_distance *src_dist = src_thing; + struct dst_rodata_distance *dst_dist = dst_thing; + dst_dist->near = srctodst32(src_dist->near); + dst_dist->far = srctodst32(src_dist->far); + dst_dist->rwdataindex = srctodst16(src_dist->rwdataindex); + dstpos += sizeof(*dst_dist); + break; + case CT_RODATA_REORDER: + struct src_rodata_reorder *src_reorder = src_thing; + struct dst_rodata_reorder *dst_reorder = dst_thing; + dst_reorder->unk00 = srctodst32(src_reorder->unk00); + dst_reorder->unk04 = srctodst32(src_reorder->unk04); + dst_reorder->unk08 = srctodst32(src_reorder->unk08); + dst_reorder->unk0c[0] = srctodst32(src_reorder->unk0c[0]); + dst_reorder->unk0c[1] = srctodst32(src_reorder->unk0c[1]); + dst_reorder->unk0c[2] = srctodst32(src_reorder->unk0c[2]); + dst_reorder->side = srctodst16(src_reorder->side); + dst_reorder->rwdataindex = srctodst16(src_reorder->rwdataindex); + dstpos += sizeof(*dst_reorder); + break; + case CT_RODATA_BBOX: + struct generic_rodata_bbox *src_bbox = src_thing; + struct generic_rodata_bbox *dst_bbox = dst_thing; + dst_bbox->hitpart = srctodst32(src_bbox->hitpart); + dst_bbox->bbox[0] = srctodst32(src_bbox->bbox[0]); + dst_bbox->bbox[1] = srctodst32(src_bbox->bbox[1]); + dst_bbox->bbox[2] = srctodst32(src_bbox->bbox[2]); + dst_bbox->bbox[3] = srctodst32(src_bbox->bbox[3]); + dst_bbox->bbox[4] = srctodst32(src_bbox->bbox[4]); + dst_bbox->bbox[5] = srctodst32(src_bbox->bbox[5]); + dstpos += sizeof(*dst_bbox); + break; + case CT_RODATA_CHRGUNFIRE: + struct src_rodata_chrgunfire *src_chrgunfire = src_thing; + struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; + dst_chrgunfire->pos[0] = srctodst32(src_chrgunfire->pos[0]); + dst_chrgunfire->pos[1] = srctodst32(src_chrgunfire->pos[1]); + dst_chrgunfire->pos[2] = srctodst32(src_chrgunfire->pos[2]); + dst_chrgunfire->dim[0] = srctodst32(src_chrgunfire->dim[0]); + dst_chrgunfire->dim[1] = srctodst32(src_chrgunfire->dim[1]); + dst_chrgunfire->dim[2] = srctodst32(src_chrgunfire->dim[2]); + dst_chrgunfire->unk1c = srctodst32(src_chrgunfire->unk1c); + dst_chrgunfire->rwdataindex = srctodst16(src_chrgunfire->rwdataindex); + dst_chrgunfire->ptr_baseaddr = 0; + dstpos += sizeof(*dst_chrgunfire); + break; + case CT_RODATA_11: + struct src_rodata_type11 *src_type11 = src_thing; + struct dst_rodata_type11 *dst_type11 = dst_thing; + dst_type11->unk00 = srctodst32(src_type11->unk00); + dst_type11->unk04 = srctodst32(src_type11->unk04); + dst_type11->unk08 = srctodst32(src_type11->unk08); + dst_type11->unk0c = srctodst32(src_type11->unk0c); + dst_type11->unk10 = srctodst32(src_type11->unk10); + dst_type11->extra1 = srctodst32(src_type11->extra1); + dst_type11->extra2 = srctodst32(src_type11->extra2); + dstpos += sizeof(*dst_type11); + break; + case CT_RODATA_TOGGLE: + struct src_rodata_toggle *src_toggle = src_thing; + struct dst_rodata_toggle *dst_toggle = dst_thing; + dst_toggle->rwdataindex = srctodst16(src_toggle->rwdataindex); + dstpos += sizeof(*dst_toggle); + break; + case CT_RODATA_POSITIONHELD: + struct generic_rodata_positionheld *src_posheld = src_thing; + struct generic_rodata_positionheld *dst_posheld = dst_thing; + dst_posheld->pos[0] = srctodst32(src_posheld->pos[0]); + dst_posheld->pos[1] = srctodst32(src_posheld->pos[1]); + dst_posheld->pos[2] = srctodst32(src_posheld->pos[2]); + dst_posheld->mtxindex = srctodst16(src_posheld->mtxindex); + dst_posheld->unk10 = srctodst32(src_posheld->unk10); + dstpos += sizeof(*dst_posheld); + break; + case CT_RODATA_STARGUNFIRE: + struct src_rodata_stargunfire *src_stargunfire = src_thing; + struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; + dst_stargunfire->unk00 = srctodst32(src_stargunfire->unk00); + dstpos += sizeof(*dst_stargunfire); + break; + case CT_RODATA_HEADSPOT: + struct generic_rodata_headspot *src_headspot = src_thing; + struct generic_rodata_headspot *dst_headspot = dst_thing; + dst_headspot->rwdataindex = srctodst16(src_headspot->rwdataindex); + dstpos += sizeof(*dst_headspot); + break; + case CT_RODATA_DL: + struct src_rodata_dl *src_dl = src_thing; + struct dst_rodata_dl *dst_dl = dst_thing; + dst_dl->numvertices = srctodst16(src_dl->numvertices); + dst_dl->mcount = srctodst16(src_dl->mcount); + dst_dl->rwdataindex = srctodst16(src_dl->rwdataindex); + dst_dl->numcolours = srctodst16(src_dl->numcolours); + dstpos += sizeof(*dst_dl); + break; + case CT_RODATA_19: + struct generic_rodata_type19 *src_type19 = src_thing; + struct generic_rodata_type19 *dst_type19 = dst_thing; + u32 *src_vertices = src_thing + sizeof(u32); + u32 *dst_vertices = dst_thing + sizeof(u32); + int num_vertices = srctoh32(src_type19->numvertices); + + dst_type19->numvertices = htodst32(num_vertices); + dstpos += sizeof(u32); + + for (int i = 0; i < num_vertices; i++) { + dst_vertices[i * 3 + 0] = srctodst32(src_vertices[i * 3 + 0]); + dst_vertices[i * 3 + 1] = srctodst32(src_vertices[i * 3 + 1]); + dst_vertices[i * 3 + 2] = srctodst32(src_vertices[i * 3 + 2]); + dstpos += sizeof(u32) * 3; + } + break; + } + + dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].after); + } + + return dstpos; +} + +static u32 resolvePointer(u32 src_offset) +{ + if (src_offset == 0) { + return 0; + } + + struct marker *marker = find_marker(src_offset & 0x00ffffff); + return marker ? (0x05000000 | marker->dst_offset) : 0; +} + +static u8 *relinkPointers(u8 *dst, u8 *src) +{ + u8 *textures_end = 0; + + for (int i = 0; i < m_NumMarkers; i++) { + struct marker *marker = &m_Markers[i]; + void *src_thing = &src[marker->src_offset]; + void *dst_thing = &dst[marker->dst_offset]; + + u8 *lowestptr = 0; + + switch (marker->type) { + case CT_MODELDEF: + struct src_modeldef *src_modeldef = src_thing; + struct dst_modeldef *dst_modeldef = dst_thing; + dst_modeldef->ptr_rootnode = htodst32(resolvePointer(srctoh32(src_modeldef->ptr_rootnode))); + dst_modeldef->ptr_parts = htodst32(resolvePointer(srctoh32(src_modeldef->ptr_parts))); + dst_modeldef->ptr_texconfigs = htodst32(resolvePointer(srctoh32(src_modeldef->ptr_texconfigs))); + break; + case CT_NODE: + struct src_modelnode *src_node = src_thing; + struct dst_modelnode *dst_node = dst_thing; + dst_node->ptr_rodata = htodst32(resolvePointer(srctoh32(src_node->ptr_rodata))); + dst_node->ptr_parent = htodst32(resolvePointer(srctoh32(src_node->ptr_parent))); + dst_node->ptr_next = htodst32(resolvePointer(srctoh32(src_node->ptr_next))); + dst_node->ptr_prev = htodst32(resolvePointer(srctoh32(src_node->ptr_prev))); + dst_node->ptr_child = htodst32(resolvePointer(srctoh32(src_node->ptr_child))); + + lowestptr = dst_node->ptr_rodata; + break; + case CT_TEXCONFIG: + struct src_texconfig *src_texconfig = src_thing; + struct dst_texconfig *dst_texconfig = dst_thing; + if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { + dst_texconfig->ptr = htodst32(resolvePointer(srctoh32(src_texconfig->ptr))); + gbiAddTexAddr(srctoh32(src_texconfig->ptr), dst_texconfig->ptr); + } + break; + case CT_PARTS: + struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + u32 *src_parts = (u32 *) src_thing; + uintptr_t *dst_parts = (uintptr_t *) dst_thing; + int num_parts = srctoh16(src_modeldef2->numparts); + + for (int i = 0; i < num_parts; i++) { + dst_parts[i] = htodst32(resolvePointer(srctoh32(src_parts[i]))); + } + break; + case CT_RODATA_CHRINFO: + break; + case CT_RODATA_POSITION: + break; + case CT_RODATA_GUNDL: + struct src_rodata_gundl *src_gundl = src_thing; + struct dst_rodata_gundl *dst_gundl = dst_thing; + dst_gundl->ptr_opagdl = htodst32(resolvePointer(srctoh32(src_gundl->ptr_opagdl))); + dst_gundl->ptr_xlugdl = htodst32(resolvePointer(srctoh32(src_gundl->ptr_xlugdl))); + dst_gundl->ptr_vertices = htodst32(resolvePointer(srctoh32(src_gundl->ptr_vertices))); + + gbiConvertVtx(dst, dst_gundl->ptr_vertices & 0x00ffffff, dst_gundl->numvertices); + + gbiSetVtx(srctoh32(src_gundl->ptr_vertices), dst_gundl->ptr_vertices); + gbiSetSegment(0x04, dst_gundl->ptr_vertices); + + gbiGdlRewriteAddrs(dst, dst_gundl->ptr_opagdl); + gbiGdlRewriteAddrs(dst, dst_gundl->ptr_xlugdl); + + if (dst_gundl->ptr_opagdl) dst_gundl->ptr_opagdl |= 1; + if (dst_gundl->ptr_xlugdl) dst_gundl->ptr_xlugdl |= 1; + + lowestptr = minPtr3(dst_gundl->ptr_opagdl, dst_gundl->ptr_xlugdl, dst_gundl->ptr_vertices); + break; + case CT_RODATA_DISTANCE: + struct src_rodata_distance *src_dist = src_thing; + struct dst_rodata_distance *dst_dist = dst_thing; + dst_dist->ptr_target = htodst32(resolvePointer(srctoh32(src_dist->ptr_target))); + break; + case CT_RODATA_REORDER: + struct src_rodata_reorder *src_reorder = src_thing; + struct dst_rodata_reorder *dst_reorder = dst_thing; + dst_reorder->ptr_node_unk18 = htodst32(resolvePointer(srctoh32(src_reorder->ptr_node_unk18))); + dst_reorder->ptr_node_unk1c = htodst32(resolvePointer(srctoh32(src_reorder->ptr_node_unk1c))); + break; + case CT_RODATA_CHRGUNFIRE: + struct src_rodata_chrgunfire *src_chrgunfire = src_thing; + struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; + dst_chrgunfire->ptr_texture = htodst32(resolvePointer(srctoh32(src_chrgunfire->ptr_texture))); + if ((srctoh32(dst_chrgunfire->ptr_texture) & 0xff000000) == 0x05000000) { + gbiAddTexAddr(srctoh32(dst_chrgunfire->ptr_texture), dst_chrgunfire->ptr_texture); + } + break; + case CT_RODATA_TOGGLE: + struct src_rodata_toggle *src_toggle = src_thing; + struct dst_rodata_toggle *dst_toggle = dst_thing; + dst_toggle->ptr_target = htodst32(resolvePointer(srctoh32(src_toggle->ptr_target))); + break; + case CT_RODATA_STARGUNFIRE: + struct src_rodata_stargunfire *src_stargunfire = src_thing; + struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; + dst_stargunfire->ptr_vertices = htodst32(resolvePointer(srctoh32(src_stargunfire->ptr_vertices))); + dst_stargunfire->ptr_gdl = htodst32(resolvePointer(srctoh32(src_stargunfire->ptr_gdl))); + + gbiConvertVtx(dst, dst_stargunfire->ptr_vertices & 0x00ffffff, dst_stargunfire->unk00*4); + + gbiSetVtx(srctoh32(src_stargunfire->ptr_vertices), dst_stargunfire->ptr_vertices); + gbiSetSegment(0x04, dst_stargunfire->ptr_vertices); + gbiGdlRewriteAddrs(dst, dst_stargunfire->ptr_gdl); + if (dst_stargunfire->ptr_gdl) dst_stargunfire->ptr_gdl |= 1; + + lowestptr = minPtr(dst_stargunfire->ptr_gdl, dst_stargunfire->ptr_vertices); + break; + case CT_RODATA_DL: + struct src_rodata_dl *src_dl = src_thing; + struct dst_rodata_dl *dst_dl = dst_thing; + dst_dl->ptr_opagdl = htodst32(resolvePointer(srctoh32(src_dl->ptr_opagdl))); + dst_dl->ptr_xlugdl = htodst32(resolvePointer(srctoh32(src_dl->ptr_xlugdl))); + dst_dl->ptr_colours = htodst32(resolvePointer(srctoh32(src_dl->ptr_colours))); + dst_dl->ptr_vertices = htodst32(resolvePointer(srctoh32(src_dl->ptr_vertices))); + + gbiConvertVtx(dst, dst_dl->ptr_vertices & 0x00ffffff, dst_dl->numvertices); + + gbiSetVtx(srctoh32(src_dl->ptr_vertices), dst_dl->ptr_vertices); + gbiSetSegment(0x04, dst_dl->ptr_vertices); + gbiGdlRewriteAddrs(dst, dst_dl->ptr_opagdl); + gbiGdlRewriteAddrs(dst, dst_dl->ptr_xlugdl); + + if (dst_dl->ptr_opagdl) dst_dl->ptr_opagdl |= 1; + if (dst_dl->ptr_xlugdl) dst_dl->ptr_xlugdl |= 1; + + lowestptr = minPtr3(dst_dl->ptr_opagdl, dst_dl->ptr_xlugdl, dst_dl->ptr_colours); + lowestptr = minPtr(lowestptr, dst_dl->ptr_vertices); + break; + case CT_TEXDATA: + case CT_VTXCOL: + case CT_GDL: + case CT_RODATA_BBOX: + case CT_RODATA_11: + case CT_RODATA_POSITIONHELD: + case CT_RODATA_HEADSPOT: + case CT_RODATA_19: + break; + } + + textures_end = minPtr(textures_end, lowestptr); + } + + return textures_end; +} + +static int convertModel(u8 *dst, u8 *src, u32 srclen) +{ + u32 dstpos; + + populateMarkers(src); + sortMarkers(); + + dstpos = convertContent(dst, src, srclen); + u8 *tex_end = relinkPointers(dst, src); + preprocessModelTextures(dst, tex_end); + + return dstpos; +} + +void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) +{ + for (uint32_t i = 0; i < size_bytes; i += 4, ++dest) { + *dest = PD_BE32(*dest); + } +} + +void preprocessModelTextures(u8 *base, u8 *textures_end) +{ + struct modeldef* mdl = (struct modeldef*)base; + if (!mdl->texconfigs) return; + + u32 ofs = 0x5000000; + struct textureconfig* texconfigs = PD_PTR_BASEOFS(mdl->texconfigs, base, ofs); + for (s16 i = 0; i < mdl->numtexconfigs; ++i) { + if ((texconfigs[i].texturenum & 0xf000000) == 0x5000000) { + // embedded texture; we need to unswizzle this + u8* texdata = PD_PTR_BASEOFS(texconfigs[i].textureptr, base, ofs); + // figure out the max possible size the texture can have, because sometimes the texconfig is wrong + const u32 maxSize = (textures_end > texconfigs[i].textureptr) ? (textures_end - texconfigs[i].textureptr) : 0; + // figure out the format and unswizzle + const s32 format = texConfigToFormat(&texconfigs[i]); + texSwizzleInternal(texdata, texconfigs[i].width, texconfigs[i].height, format, maxSize); + + if (format == TEXFORMAT_RGBA32) { + // for some reason, RGBA32 embedded textures don't need to be byte-swapped, + // so we byte-swap them here, which will be undone when the renderer imports it + u32 size_bytes = texconfigs[i].width * texconfigs[i].height * 4; + preprocessTextureRGBA32Embedded((u32*)texdata, size_bytes); + } + } + } +} + +u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize) +{ + gbiReset(); + + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_MODEL); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); + + u32 newSize = convertModel(dst, data, size); + + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); + + *outSize = newSize; + + return 0; +} + +u8 *preprocessGunFile(u8 *data, u32 size, u32 *outSize) +{ + gbiReset(); + + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_MODEL); + u8 *dst = sysMemZeroAlloc(newSizeEstimated+128); + + u32 newSize = convertModel(dst, data, size); + + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); + + *outSize = newSize; + + return 0; +} diff --git a/port/src/preprocess/filepads.c b/port/src/preprocess/filepads.c new file mode 100644 index 000000000..f1f42ee52 --- /dev/null +++ b/port/src/preprocess/filepads.c @@ -0,0 +1,330 @@ +#include +#include +#include + +#include "common.h" +#include "romdata.h" +#include "system.h" + +#define PADFLAG_INTPOS 0x0001 +#define PADFLAG_UPALIGNTOX 0x0002 +#define PADFLAG_UPALIGNTOY 0x0004 +#define PADFLAG_UPALIGNTOZ 0x0008 +#define PADFLAG_UPALIGNINVERT 0x0010 +#define PADFLAG_LOOKALIGNTOX 0x0020 +#define PADFLAG_LOOKALIGNTOY 0x0040 +#define PADFLAG_LOOKALIGNTOZ 0x0080 +#define PADFLAG_LOOKALIGNINVERT 0x0100 +#define PADFLAG_HASBBOXDATA 0x0200 + +struct n64_header { + s32 num_pads; + s32 num_covers; + u32 ptr_waypoints; + u32 ptr_waygroups; + u32 ptr_cover; +}; + +struct host_header { + s32 num_pads; + s32 num_covers; + uintptr_t ptr_waypoints; + uintptr_t ptr_waygroups; + uintptr_t ptr_cover; +}; + +struct padheader { + u32 flags : 18; + u32 room : 10; + u32 liftnum : 4; +}; + +struct n64_waypoint { + s32 padnum; + u32 ptr_neighbours; + s32 groupnum; + s32 step; +}; + +struct host_waypoint { + s32 padnum; + uintptr_t ptr_neighbours; + s32 groupnum; + s32 step; +}; + +struct n64_waygroup { + u32 ptr_neighbours; + u32 ptr_waypoints; + s32 step; +}; + +struct host_waygroup { + uintptr_t ptr_neighbours; + uintptr_t ptr_waypoints; + s32 step; +}; + +struct generic_coverdefinition { + u32 pos[3]; + u32 dir[3]; + u16 flags; + u16 unk1a; +}; + +static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) +{ + u16 *src_offsets = (u16 *) &src[srcpos]; + u16 *dst_offsets = (u16 *) &dst[dstpos]; + + dstpos += num_pads * sizeof(u16); + + for (int i = 0; i < num_pads; i++) { + dstpos = ALIGN4(dstpos); + srcpos = srctoh16(src_offsets[i]); + + dst_offsets[i] = htodst16(dstpos); + + // Header + u32 n64_padheader = srctoh32(*(u32 *) &src[srcpos]); + struct padheader *host_padheader = (struct padheader *) &dst[dstpos]; + u32 flags = (n64_padheader >> 14) & 0x3ffff; + + *(u32*)host_padheader = htodst32(n64_padheader); + + srcpos += sizeof(struct padheader); + dstpos += sizeof(struct padheader); + + // Position + if (flags & PADFLAG_INTPOS) { + s16 *srcptr = (s16 *) &src[srcpos]; + s16 *dstptr = (s16 *) &dst[dstpos]; + + dstptr[0] = srctodst16(srcptr[0]); + dstptr[1] = srctodst16(srcptr[1]); + dstptr[2] = srctodst16(srcptr[2]); + + srcpos += 8; + dstpos += 8; + } else { + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; + + dstptr[0] = srctodst32(srcptr[0]); + dstptr[1] = srctodst32(srcptr[1]); + dstptr[2] = srctodst32(srcptr[2]); + + srcpos += 12; + dstpos += 12; + } + + // Up + if ((flags & (PADFLAG_UPALIGNTOX | PADFLAG_UPALIGNTOY | PADFLAG_UPALIGNTOZ)) == 0) { + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; + + dstptr[0] = srctodst32(srcptr[0]); + dstptr[1] = srctodst32(srcptr[1]); + dstptr[2] = srctodst32(srcptr[2]); + + srcpos += 12; + dstpos += 12; + } + + // Look + if ((flags & (PADFLAG_LOOKALIGNTOX | PADFLAG_LOOKALIGNTOY | PADFLAG_LOOKALIGNTOZ)) == 0) { + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; + + dstptr[0] = srctodst32(srcptr[0]); + dstptr[1] = srctodst32(srcptr[1]); + dstptr[2] = srctodst32(srcptr[2]); + + srcpos += 12; + dstpos += 12; + } + + // Bbox + if (flags & PADFLAG_HASBBOXDATA) { + u32 *srcptr = (u32 *) &src[srcpos]; + u32 *dstptr = (u32 *) &dst[dstpos]; + + dstptr[0] = srctodst32(srcptr[0]); + dstptr[1] = srctodst32(srcptr[1]); + dstptr[2] = srctodst32(srcptr[2]); + dstptr[3] = srctodst32(srcptr[3]); + dstptr[4] = srctodst32(srcptr[4]); + dstptr[5] = srctodst32(srcptr[5]); + + srcpos += 4 * 6; + dstpos += 4 * 6; + } + } + + return dstpos; +} + +static int convertWayPoints(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct n64_waypoint *n64_waypoints = (struct n64_waypoint *) &src[srcpos]; + struct host_waypoint *host_waypoints = (struct host_waypoint *) &dst[dstpos]; + int num_waypoints; + + for (num_waypoints = 0; n64_waypoints[num_waypoints].padnum != -1; num_waypoints++); + + dstpos += (num_waypoints + 1) * sizeof(struct host_waypoint); + + u32 *host_neighbours = (u32 *) &dst[dstpos]; + int n = 0; + + for (int i = 0; i < num_waypoints; i++) { + host_waypoints[i].padnum = srctodst32(n64_waypoints[i].padnum); + host_waypoints[i].ptr_neighbours = htodst32(dstpos); + host_waypoints[i].groupnum = srctodst32(n64_waypoints[i].groupnum); + host_waypoints[i].step = 0; + + u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waypoints[i].ptr_neighbours)]; + + for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { + host_neighbours[n++] = srctodst32(n64_neighbours[j]); + dstpos += 4; + } + + host_neighbours[n++] = 0xffffffff; + dstpos += 4; + } + + // Terminator + host_waypoints[num_waypoints].padnum = 0xffffffff; + host_waypoints[num_waypoints].ptr_neighbours = 0; + host_waypoints[num_waypoints].groupnum = 0; + host_waypoints[num_waypoints].step = 0; + + return dstpos; +} + +static int convertWayGroups(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct n64_waygroup *n64_waygroups = (struct n64_waygroup *) &src[srcpos]; + struct host_waygroup *host_waygroups = (struct host_waygroup *) &dst[dstpos]; + int num_waygroups; + + for (num_waygroups = 0; n64_waygroups[num_waygroups].ptr_neighbours != 0; num_waygroups++); + + dstpos += (num_waygroups + 1) * sizeof(struct host_waygroup); + + // Waygroups and child waypoints + u32 *host_waypoints = (u32 *) &dst[dstpos]; + int n = 0; + + for (int i = 0; i < num_waygroups; i++) { + host_waygroups[i].ptr_waypoints = htodst32(dstpos); + host_waygroups[i].step = 0; + + u32 *n64_waypoints = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_waypoints)]; + + for (int j = 0; n64_waypoints[j] != 0xffffffff; j++) { + host_waypoints[n++] = srctodst32(n64_waypoints[j]); + dstpos += 4; + } + + host_waypoints[n++] = 0xffffffff; + dstpos += 4; + } + + // Terminator + host_waygroups[num_waygroups].ptr_neighbours = 0; + host_waygroups[num_waygroups].ptr_waypoints = 0; + host_waygroups[num_waygroups].step = 0; + + // Waygroup neighbours + u32 *host_neighbours = (u32 *) &dst[dstpos]; + n = 0; + + for (int i = 0; i < num_waygroups; i++) { + host_waygroups[i].ptr_neighbours = htodst32(dstpos); + + u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_neighbours)]; + + for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { + host_neighbours[n++] = srctodst32(n64_neighbours[j]); + dstpos += 4; + } + + host_neighbours[n++] = 0xffffffff; + dstpos += 4; + } + + return dstpos; +} + +static int convertCover(u8 *dst, int dstpos, u8 *src, int srcpos, int num_covers) +{ + struct generic_coverdefinition *n64_covers = (struct generic_coverdefinition *) &src[srcpos]; + struct generic_coverdefinition *host_covers = (struct generic_coverdefinition *) &dst[dstpos]; + + for (int i = 0; i < num_covers; i++) { + host_covers[i].pos[0] = srctodst32(n64_covers[i].pos[0]); + host_covers[i].pos[1] = srctodst32(n64_covers[i].pos[1]); + host_covers[i].pos[2] = srctodst32(n64_covers[i].pos[2]); + host_covers[i].dir[0] = srctodst32(n64_covers[i].dir[0]); + host_covers[i].dir[1] = srctodst32(n64_covers[i].dir[1]); + host_covers[i].dir[2] = srctodst32(n64_covers[i].dir[2]); + host_covers[i].flags = srctodst16(n64_covers[i].flags); + host_covers[i].unk1a = srctodst16(n64_covers[i].unk1a); + } + + dstpos += num_covers * sizeof(struct generic_coverdefinition); + + return dstpos; +} + +static int convertPadsFile(u8 *dst, u8 *src) +{ + int dstpos = 0; + struct n64_header *n64_header = (struct n64_header *) src; + struct host_header *host_header = (struct host_header *) dst; + + int num_pads = srctoh32(n64_header->num_pads); + int num_covers = srctoh32(n64_header->num_covers); + host_header->num_pads = htodst32(num_pads); + host_header->num_covers = htodst32(num_covers); + + dstpos += sizeof(struct host_header); + + // Pads + dstpos = convertPads(dst, dstpos, src, sizeof(struct n64_header), num_pads); + + // Waypoints + host_header->ptr_waypoints = htodst32(dstpos); + dstpos = convertWayPoints(dst, dstpos, src, srctoh32(n64_header->ptr_waypoints)); + + // Waygroups + host_header->ptr_waygroups = htodst32(dstpos); + dstpos = convertWayGroups(dst, dstpos, src, srctoh32(n64_header->ptr_waygroups)); + + // Cover + host_header->ptr_cover = htodst32(dstpos); + dstpos = convertCover(dst, dstpos, src, srctoh32(n64_header->ptr_cover), num_covers); + + return dstpos; +} + +u8* preprocessPadsFile(u8 *data, u32 size, u32 *outSize) { + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_PADS); + u8* dst = sysMemZeroAlloc(newSizeEstimated); + + u32 newSize = convertPadsFile(dst, data); + + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a pads file, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); + + *outSize = newSize; + + return 0; +} diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c new file mode 100644 index 000000000..9d4c9c7b2 --- /dev/null +++ b/port/src/preprocess/filesetup.c @@ -0,0 +1,1202 @@ +#include +#include +#include + +#include "types.h" + +#include "assert.h" + +#include "common.h" +#include "setups_decl.h" + +#include "romdata.h" +#include "system.h" + + +static inline void convF32(f32 *dst, f32 src) { *(u32*)dst = srctoh32(*(u32*)&src); } +static inline void convU32(u32 *dst, u32 src) { *dst = srctoh32(src); } +static inline void convS32(s32 *dst, s32 src) { *dst = srctoh32(src); } +static inline void convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } +static inline void convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } +static inline void cpyByte(u8 *dst, u8 src) { *dst = src; } +static inline void convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } +static u32 convUnk(void* x, u32 y) { __debugbreak(); } + +#define PD_CONV_VAL(dst, src) _Generic((dst), \ + f32: convF32, \ + u32: convU32, \ + s32: convS32, \ + u16: convU16, \ + s16: convS16, \ + u8: cpyByte, \ + s8: cpyByte, \ + struct coord: convCoord, \ + default: convUnk \ +)(&dst, src) + +#define PD_CONV_ARRAY(dst, src) { for (int i = 0; i < ARRAYCOUNT(dst); i++) PD_CONV_VAL(dst[i], src[i]); } +#define PD_CONV_ARRAY2D(dst, src) { \ + for (int i = 0; i < ARRAYCOUNT(dst); i++) \ + for (int j = 0; j < ARRAYCOUNT(dst); j++) PD_CONV_VAL(dst[i][j], src[i][j]); \ +} + +#define PD_CONV_PTR(dst, src) dst = srctoh32(src) + +static u32 obj_size(struct n64_defaultobj *obj) +{ + switch (obj->type) { + case OBJTYPE_CHR: return sizeof(struct n64_packedchr) / sizeof(u32); + case OBJTYPE_DOOR: return sizeof(struct n64_doorobj) / sizeof(u32); + case OBJTYPE_DOORSCALE: return sizeof(struct n64_doorscaleobj) / sizeof(u32); + case OBJTYPE_BASIC: return sizeof(struct n64_defaultobj) / sizeof(u32); + case OBJTYPE_DEBRIS: return sizeof(struct n64_debrisobj) / sizeof(u32); + case OBJTYPE_GLASS: return sizeof(struct n64_glassobj) / sizeof(u32); + case OBJTYPE_TINTEDGLASS: return sizeof(struct n64_tintedglassobj) / sizeof(u32); + case OBJTYPE_SAFE: return sizeof(struct n64_safeobj) / sizeof(u32); + case OBJTYPE_GASBOTTLE: return sizeof(struct gasbottleobj) / sizeof(u32); + case OBJTYPE_KEY: return sizeof(struct n64_keyobj) / sizeof(u32); + case OBJTYPE_ALARM: return sizeof(struct n64_alarmobj) / sizeof(u32); + case OBJTYPE_CCTV: return sizeof(struct n64_cctvobj) / sizeof(u32); + case OBJTYPE_AMMOCRATE: return sizeof(struct n64_ammocrateobj) / sizeof(u32); + case OBJTYPE_WEAPON: return sizeof(struct n64_weaponobj) / sizeof(u32); + case OBJTYPE_SINGLEMONITOR: return sizeof(struct n64_singlemonitorobj) / sizeof(u32); + case OBJTYPE_MULTIMONITOR: return sizeof(struct n64_multimonitorobj) / sizeof(u32); + case OBJTYPE_HANGINGMONITORS: return sizeof(struct n64_hangingmonitorsobj) / sizeof(u32); + case OBJTYPE_AUTOGUN: return sizeof(struct n64_autogunobj) / sizeof(u32); + case OBJTYPE_LINKGUNS: return sizeof(struct linkgunsobj) / sizeof(u32); + case OBJTYPE_HAT: return sizeof(struct n64_hatobj) / sizeof(u32); + case OBJTYPE_GRENADEPROB: return sizeof(struct grenadeprobobj) / sizeof(u32); + case OBJTYPE_LINKLIFTDOOR: return sizeof(struct n64_linkliftdoorobj) / sizeof(u32); + case OBJTYPE_SAFEITEM: return sizeof(struct n64_safeitemobj) / sizeof(u32); + case OBJTYPE_MULTIAMMOCRATE: return sizeof(struct n64_multiammocrateobj) / sizeof(u32); + case OBJTYPE_SHIELD: return sizeof(struct n64_shieldobj) / sizeof(u32); + case OBJTYPE_TAG: return sizeof(struct n64_tag) / sizeof(u32); + case OBJTYPE_RENAMEOBJ: return sizeof(struct n64_textoverride) / sizeof(u32); + case OBJTYPE_BEGINOBJECTIVE: return sizeof(struct n64_objective) / sizeof(u32); + case OBJTYPE_ENDOBJECTIVE: return 1; + case OBJECTIVETYPE_DESTROYOBJ: return 2; + case OBJECTIVETYPE_COMPFLAGS: return 2; + case OBJECTIVETYPE_FAILFLAGS: return 2; + case OBJECTIVETYPE_COLLECTOBJ: return 2; + case OBJECTIVETYPE_THROWOBJ: return 2; + case OBJECTIVETYPE_HOLOGRAPH: return sizeof(struct n64_criteria_holograph) / sizeof(u32); + case OBJECTIVETYPE_1F: return 1; + case OBJECTIVETYPE_ENTERROOM: return sizeof(struct n64_criteria_roomentered) / sizeof(u32); + case OBJECTIVETYPE_THROWINROOM: return sizeof(struct n64_criteria_throwinroom) / sizeof(u32); + case OBJTYPE_22: return 1; + case OBJTYPE_BRIEFING: return sizeof(struct n64_briefingobj) / sizeof(u32); + case OBJTYPE_PADLOCKEDDOOR: return sizeof(struct n64_padlockeddoorobj) / sizeof(u32); + case OBJTYPE_TRUCK: return sizeof(struct n64_truckobj) / sizeof(u32); + case OBJTYPE_HELI: return sizeof(struct n64_heliobj) / sizeof(u32); + case OBJTYPE_TANK: return 32; + case OBJTYPE_CAMERAPOS: return sizeof(struct n64_cameraposobj) / sizeof(u32); + case OBJTYPE_LIFT: return sizeof(struct n64_liftobj) / sizeof(u32); + case OBJTYPE_CONDITIONALSCENERY: return sizeof(struct n64_linksceneryobj) / sizeof(u32); + case OBJTYPE_BLOCKEDPATH: return sizeof(struct n64_blockedpathobj) / sizeof(u32); + case OBJTYPE_HOVERBIKE: return sizeof(struct n64_hoverbikeobj) / sizeof(u32); + case OBJTYPE_HOVERPROP: return sizeof(struct n64_hoverpropobj) / sizeof(u32); + case OBJTYPE_FAN: return sizeof(struct n64_fanobj) / sizeof(u32); + case OBJTYPE_HOVERCAR: return sizeof(struct n64_hovercarobj) / sizeof(u32); + case OBJTYPE_CHOPPER: return sizeof(struct n64_chopperobj) / sizeof(u32); + case OBJTYPE_PADEFFECT: return sizeof(struct padeffectobj) / sizeof(u32); + case OBJTYPE_MINE: return sizeof(struct n64_weaponobj) / sizeof(u32); + case OBJTYPE_ESCASTEP: return sizeof(struct n64_escalatorobj) / sizeof(u32); + } + + return 1; +} + + +void conv_tvscreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) +{ + PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist); + PD_CONV_VAL(dstobj->offset, srcobj->offset); + PD_CONV_VAL(dstobj->pause60, srcobj->pause60); + PD_CONV_PTR(dstobj->tconfig, srcobj->ptr_tconfig); + PD_CONV_VAL(dstobj->rot, srcobj->rot); + PD_CONV_VAL(dstobj->xscale, srcobj->xscale); + PD_CONV_VAL(dstobj->xscalefrac, srcobj->xscalefrac); + PD_CONV_VAL(dstobj->xscaleinc, srcobj->xscaleinc); + PD_CONV_VAL(dstobj->xscaleold, srcobj->xscaleold); + PD_CONV_VAL(dstobj->xscalenew, srcobj->xscalenew); + PD_CONV_VAL(dstobj->yscale, srcobj->yscale); + PD_CONV_VAL(dstobj->yscalefrac, srcobj->yscalefrac); + PD_CONV_VAL(dstobj->yscaleinc, srcobj->yscaleinc); + PD_CONV_VAL(dstobj->yscaleold, srcobj->yscaleold); + PD_CONV_VAL(dstobj->yscalenew, srcobj->yscalenew); + PD_CONV_VAL(dstobj->xmid, srcobj->xmid); + PD_CONV_VAL(dstobj->xmidfrac, srcobj->xmidfrac); + PD_CONV_VAL(dstobj->xmidinc, srcobj->xmidinc); + PD_CONV_VAL(dstobj->xmidold, srcobj->xmidold); + PD_CONV_VAL(dstobj->xmidnew, srcobj->xmidnew); + PD_CONV_VAL(dstobj->ymid, srcobj->ymid); + PD_CONV_VAL(dstobj->ymidfrac, srcobj->ymidfrac); + PD_CONV_VAL(dstobj->ymidinc, srcobj->ymidinc); + PD_CONV_VAL(dstobj->ymidold, srcobj->ymidold); + PD_CONV_VAL(dstobj->ymidnew, srcobj->ymidnew); + PD_CONV_VAL(dstobj->red, srcobj->red); + PD_CONV_VAL(dstobj->redold, srcobj->redold); + PD_CONV_VAL(dstobj->rednew, srcobj->rednew); + PD_CONV_VAL(dstobj->green, srcobj->green); + PD_CONV_VAL(dstobj->greenold, srcobj->greenold); + PD_CONV_VAL(dstobj->greennew, srcobj->greennew); + PD_CONV_VAL(dstobj->blue, srcobj->blue); + PD_CONV_VAL(dstobj->blueold, srcobj->blueold); + PD_CONV_VAL(dstobj->bluenew, srcobj->bluenew); + PD_CONV_VAL(dstobj->alpha, srcobj->alpha); + PD_CONV_VAL(dstobj->alphaold, srcobj->alphaold); + PD_CONV_VAL(dstobj->alphanew, srcobj->alphanew); + PD_CONV_VAL(dstobj->colfrac, srcobj->colfrac); + PD_CONV_VAL(dstobj->colinc, srcobj->colinc); +} + +void convertDefaultObjHdr(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) +{ + PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); + + /* 'header' is like this inside a u32: + u16 unk00_1, + u8 unk00_2, + u8 type, + */ + u16 *dst_unk00_1 = (u16*)&dstobj->extrascale; + u8 *dst_unk00_2 = (u8*)(dst_unk00_1 + 1); + + u16 *src_unk00_1 = (u16*)&srcobj->extrascale; + u8 *src_unk00_2 = (u8*)(src_unk00_1 + 1); + + *dst_unk00_1 = srctoh16(*src_unk00_1); + dst_unk00_2[0] = src_unk00_2[0]; + dst_unk00_2[1] = src_unk00_2[1]; +} + +void convertDefaultObj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) +{ + PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); + PD_CONV_VAL(dstobj->hidden2, srcobj->hidden2); + PD_CONV_VAL(dstobj->type, srcobj->type); + PD_CONV_VAL(dstobj->modelnum, srcobj->modelnum); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->flags2, srcobj->flags2); + PD_CONV_VAL(dstobj->flags3, srcobj->flags3); + PD_CONV_PTR(dstobj->prop, srcobj->ptr_prop); + PD_CONV_PTR(dstobj->model, srcobj->ptr_model); + PD_CONV_ARRAY2D(dstobj->realrot, srcobj->realrot); + PD_CONV_VAL(dstobj->hidden, srcobj->hidden); + PD_CONV_PTR(dstobj->unkgeo, srcobj->ptr_unkgeo); + PD_CONV_PTR(dstobj->embedment, srcobj->ptr_embedment); + PD_CONV_VAL(dstobj->damage, srcobj->damage); + PD_CONV_VAL(dstobj->maxdamage, srcobj->maxdamage); + PD_CONV_ARRAY(dstobj->shadecol, srcobj->shadecol); + PD_CONV_ARRAY(dstobj->nextcol, srcobj->nextcol); + PD_CONV_VAL(dstobj->floorcol, srcobj->floorcol); + PD_CONV_VAL(dstobj->geocount, srcobj->geocount); +} + +u32 convertProps(u8* dst, u8* src) +{ + u8* start = dst; + struct n64_defaultobj* cmd = (struct n64_defaultobj*)src; + + int i = 0; + u8 type = cmd->type; + + while (type != OBJTYPE_END) { + //sysLogPrintf(LOG_NOTE, "#%03d obj 0x%02x (%s)", ++i, type, objName(cmd)); + switch (type) { + case OBJTYPE_DOOR: + { + struct n64_doorobj* srcobj = (struct n64_doorobj*)cmd; + struct doorobj* dstobj = (struct doorobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->maxfrac, srcobj->maxfrac); + PD_CONV_VAL(dstobj->perimfrac, srcobj->perimfrac); + PD_CONV_VAL(dstobj->accel, srcobj->accel); + PD_CONV_VAL(dstobj->decel, srcobj->decel); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->doorflags, srcobj->doorflags); + PD_CONV_VAL(dstobj->doortype, srcobj->doortype); + PD_CONV_VAL(dstobj->keyflags, srcobj->keyflags); + PD_CONV_VAL(dstobj->autoclosetime, srcobj->autoclosetime); + PD_CONV_VAL(dstobj->frac, srcobj->frac); + PD_CONV_VAL(dstobj->fracspeed, srcobj->fracspeed); + PD_CONV_VAL(dstobj->mode, srcobj->mode); + PD_CONV_VAL(dstobj->glasshits, srcobj->glasshits); + PD_CONV_VAL(dstobj->fadealpha, srcobj->fadealpha); + PD_CONV_VAL(dstobj->xludist, srcobj->xludist); + PD_CONV_VAL(dstobj->opadist, srcobj->opadist); + PD_CONV_VAL(dstobj->startpos, srcobj->startpos); + PD_CONV_ARRAY2D(dstobj->mtx98, srcobj->mtx98); + PD_CONV_PTR(dstobj->sibling, srcobj->ptr_sibling); + PD_CONV_VAL(dstobj->lastopen60, srcobj->lastopen60); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); + PD_CONV_VAL(dstobj->fadetime60, srcobj->fadetime60); + PD_CONV_VAL(dstobj->lastcalc60, srcobj->lastcalc60); + PD_CONV_VAL(dstobj->laserfade, srcobj->laserfade); + PD_CONV_ARRAY(dstobj->unusedmaybe, srcobj->unusedmaybe); + PD_CONV_ARRAY(dstobj->shadeinfo1, srcobj->shadeinfo1); + PD_CONV_ARRAY(dstobj->shadeinfo2, srcobj->shadeinfo2); + + PD_CONV_VAL(dstobj->actual1, srcobj->actual1); + PD_CONV_VAL(dstobj->actual2, srcobj->actual2); + PD_CONV_VAL(dstobj->extra1, srcobj->extra1); + PD_CONV_VAL(dstobj->extra2, srcobj->extra2); + + dst += sizeof(struct doorobj); + break; + } + case OBJTYPE_DOORSCALE: + { + struct n64_doorscaleobj* srcobj = (struct n64_doorscaleobj*)cmd; + struct doorscaleobj* dstobj = (struct doorscaleobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->scale, srcobj->scale); + + dst += sizeof(struct doorscaleobj); + break; + } + case OBJTYPE_BASIC: + case OBJTYPE_HANGINGMONITORS: + case OBJTYPE_DEBRIS: + case OBJTYPE_HAT: + case OBJTYPE_ALARM: + { + struct n64_defaultobj* srcobj = (struct n64_defaultobj*)cmd; + struct defaultobj* dstobj = (struct defaultobj*)dst; + + convertDefaultObj(dstobj, cmd); + + dst += sizeof(struct defaultobj); + break; + } + case OBJTYPE_KEY: + { + struct n64_keyobj* srcobj = (struct n64_keyobj*)cmd; + struct keyobj* dstobj = (struct keyobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->keyflags, srcobj->keyflags); + + dst += sizeof(struct keyobj); + src += sizeof(struct n64_keyobj); + break; + } + case OBJTYPE_CCTV: + { + struct n64_cctvobj* srcobj = (struct n64_cctvobj*)cmd; + struct cctvobj* dstobj = (struct cctvobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->lookatpadnum, srcobj->lookatpadnum); + PD_CONV_VAL(dstobj->toleft, srcobj->toleft); + PD_CONV_VAL(dstobj->yzero, srcobj->yzero); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yleft, srcobj->yleft); + PD_CONV_VAL(dstobj->yright, srcobj->yright); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->ymaxspeed, srcobj->ymaxspeed); + PD_CONV_VAL(dstobj->seebondtime60, srcobj->seebondtime60); + PD_CONV_VAL(dstobj->maxdist, srcobj->maxdist); + PD_CONV_VAL(dstobj->xzero, srcobj->xzero); + + dst += sizeof(struct cctvobj); + break; + } + case OBJTYPE_AMMOCRATE: + { + struct n64_ammocrateobj* srcobj = (struct n64_ammocrateobj*)cmd; + struct ammocrateobj* dstobj = (struct ammocrateobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->ammotype, srcobj->ammotype); + + dst += sizeof(struct ammocrateobj); + break; + } + case OBJTYPE_WEAPON: + case OBJTYPE_MINE: + { + struct n64_weaponobj* srcobj = (struct n64_weaponobj*)cmd; + struct weaponobj* dstobj = (struct weaponobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->weaponnum, srcobj->weaponnum); + PD_CONV_VAL(dstobj->unk5d, srcobj->unk5d); + PD_CONV_VAL(dstobj->unk5e, srcobj->unk5e); + PD_CONV_VAL(dstobj->gunfunc, srcobj->gunfunc); + + PD_CONV_VAL(dstobj->fadeouttimer60, srcobj->fadeouttimer60); + PD_CONV_VAL(dstobj->dualweaponnum, srcobj->dualweaponnum); + + PD_CONV_VAL(dstobj->team, srcobj->team); + + PD_CONV_PTR(dstobj->dualweapon, srcobj->ptr_dualweapon); + + dst += sizeof(struct weaponobj); + break; + } + case OBJTYPE_CHR: + { + struct n64_packedchr* srcobj = (struct n64_packedchr*)cmd; + struct packedchr* dstobj = (struct packedchr*)dst; + + PD_CONV_VAL(dstobj->chrindex, srcobj->chrindex); + PD_CONV_VAL(dstobj->unk02, srcobj->unk02); + PD_CONV_VAL(dstobj->typenum, srcobj->typenum); + PD_CONV_VAL(dstobj->spawnflags, srcobj->spawnflags); + PD_CONV_VAL(dstobj->chrnum, srcobj->chrnum); + PD_CONV_VAL(dstobj->padnum, srcobj->padnum); + PD_CONV_VAL(dstobj->bodynum, srcobj->bodynum); + PD_CONV_VAL(dstobj->headnum, srcobj->headnum); + PD_CONV_VAL(dstobj->ailistnum, srcobj->ailistnum); + PD_CONV_VAL(dstobj->padpreset, srcobj->padpreset); + PD_CONV_VAL(dstobj->chrpreset, srcobj->chrpreset); + PD_CONV_VAL(dstobj->hearscale, srcobj->hearscale); + PD_CONV_VAL(dstobj->viewdist, srcobj->viewdist); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->flags2, srcobj->flags2); + PD_CONV_VAL(dstobj->team, srcobj->team); + PD_CONV_VAL(dstobj->squadron, srcobj->squadron); + PD_CONV_VAL(dstobj->chair, srcobj->chair); + PD_CONV_VAL(dstobj->convtalk, srcobj->convtalk); + PD_CONV_VAL(dstobj->tude, srcobj->tude); + PD_CONV_VAL(dstobj->naturalanim, srcobj->naturalanim); + PD_CONV_VAL(dstobj->yvisang, srcobj->yvisang); + PD_CONV_VAL(dstobj->teamscandist, srcobj->teamscandist); + + dst += sizeof(struct packedchr); + break; + } + case OBJTYPE_SINGLEMONITOR: + { + struct n64_singlemonitorobj* srcobj = (struct n64_singlemonitorobj*)cmd; + struct singlemonitorobj* dstobj = (struct singlemonitorobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + conv_tvscreen(&dstobj->screen, &srcobj->screen); + + PD_CONV_VAL(dstobj->owneroffset, srcobj->owneroffset); + PD_CONV_VAL(dstobj->ownerpart, srcobj->ownerpart); + PD_CONV_VAL(dstobj->imagenum, srcobj->imagenum); + + dst += sizeof(struct singlemonitorobj); + break; + } + case OBJTYPE_MULTIMONITOR: + { + struct n64_multimonitorobj* srcobj = (struct n64_multimonitorobj*)cmd; + struct multimonitorobj* dstobj = (struct multimonitorobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + for (size_t i = 0; i < 4; i++) + conv_tvscreen(&dstobj->screens[i], &srcobj->screens[i]); + + PD_CONV_ARRAY(dstobj->imagenums, srcobj->imagenums); + dst += sizeof(struct multimonitorobj); + break; + } + case OBJTYPE_AUTOGUN: + { + struct n64_autogunobj* srcobj = (struct n64_autogunobj*)cmd; + struct autogunobj* dstobj = (struct autogunobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->targetpad, srcobj->targetpad); + PD_CONV_VAL(dstobj->firing, srcobj->firing); + PD_CONV_VAL(dstobj->firecount, srcobj->firecount); + PD_CONV_VAL(dstobj->yzero, srcobj->yzero); + PD_CONV_VAL(dstobj->ymaxleft, srcobj->ymaxleft); + PD_CONV_VAL(dstobj->ymaxright, srcobj->ymaxright); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->xzero, srcobj->xzero); + PD_CONV_VAL(dstobj->xrot, srcobj->xrot); + PD_CONV_VAL(dstobj->xspeed, srcobj->xspeed); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->aimdist, srcobj->aimdist); + PD_CONV_VAL(dstobj->barrelspeed, srcobj->barrelspeed); + PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); + PD_CONV_VAL(dstobj->lastseebond60, srcobj->lastseebond60); + PD_CONV_VAL(dstobj->lastaimbond60, srcobj->lastaimbond60); + PD_CONV_VAL(dstobj->allowsoundframe, srcobj->allowsoundframe); + PD_CONV_PTR(dstobj->beam, srcobj->ptr_beam); + PD_CONV_VAL(dstobj->shotbondsum, srcobj->shotbondsum); + PD_CONV_PTR(dstobj->target, srcobj->ptr_target); + PD_CONV_VAL(dstobj->targetteam, srcobj->targetteam); + PD_CONV_VAL(dstobj->ammoquantity, srcobj->ammoquantity); + PD_CONV_VAL(dstobj->nextchrtest, srcobj->nextchrtest); + + dst += sizeof(struct autogunobj); + break; + } + case OBJTYPE_LINKGUNS: + { + struct n64_linkgunsobj* srcobj = (struct n64_linkgunsobj*)cmd; + struct linkgunsobj* dstobj = (struct linkgunsobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->offset1, srcobj->offset1); + PD_CONV_VAL(dstobj->offset2, srcobj->offset2); + + dst += sizeof(struct linkgunsobj); + break; + } + case OBJTYPE_GRENADEPROB: + { + struct n64_grenadeprobobj* srcobj = (struct n64_grenadeprobobj*)cmd; + struct grenadeprobobj* dstobj = (struct grenadeprobobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->chrnum, srcobj->chrnum); + PD_CONV_VAL(dstobj->probability, srcobj->probability); + + dst += sizeof(struct grenadeprobobj); + break; + } + case OBJTYPE_LINKLIFTDOOR: + { + struct n64_linkliftdoorobj* srcobj = (struct n64_linkliftdoorobj*)cmd; + struct linkliftdoorobj* dstobj = (struct linkliftdoorobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->lift, srcobj->ptr_lift); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_VAL(dstobj->stopnum, srcobj->stopnum); + + dst += sizeof(struct linkliftdoorobj); + break; + } + case OBJTYPE_MULTIAMMOCRATE: + { + struct n64_multiammocrateobj* srcobj = (struct n64_multiammocrateobj*)cmd; + struct multiammocrateobj* dstobj = (struct multiammocrateobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + for (size_t i = 0; i < 19; i++) { + PD_CONV_VAL(dstobj->slots[i].modelnum, srcobj->slots[i].modelnum); + PD_CONV_VAL(dstobj->slots[i].quantity, srcobj->slots[i].quantity); + } + + dst += sizeof(struct multiammocrateobj); + break; + } + case OBJTYPE_SHIELD: + { + struct n64_shieldobj* srcobj = (struct n64_shieldobj*)cmd; + struct shieldobj* dstobj = (struct shieldobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->initialamount, srcobj->initialamount); + PD_CONV_VAL(dstobj->amount, srcobj->amount); + PD_CONV_VAL(dstobj->unk64, srcobj->unk64); + + dst += sizeof(struct shieldobj); + break; + } + case OBJTYPE_TAG: + { + struct n64_tag* srcobj = (struct n64_tag*)cmd; + struct tag* dstobj = (struct tag*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->tagnum, srcobj->tagnum); + PD_CONV_VAL(dstobj->cmdoffset, srcobj->cmdoffset); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + + dst += sizeof(struct tag); + break; + } + case OBJTYPE_BEGINOBJECTIVE: + { + struct n64_objective* srcobj = (struct n64_objective*)cmd; + struct objective* dstobj = (struct objective*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->index, srcobj->index); + PD_CONV_VAL(dstobj->text, srcobj->text); + PD_CONV_VAL(dstobj->unk0c, srcobj->unk0c); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->difficulties, srcobj->difficulties); + + dst += sizeof(struct objective); + break; + } + case OBJTYPE_ENDOBJECTIVE: + case OBJECTIVETYPE_1F: + case OBJTYPE_22: + case OBJTYPE_GASBOTTLE: + case OBJTYPE_29: + case OBJTYPE_SAFE: + { + struct n64_stdobjective* srcobj = (struct n64_stdobjective*)cmd; + struct n64_stdobjective* dstobj = (struct n64_stdobjective*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + + dst += sizeof(struct n64_stdobjective); + break; + } + case OBJECTIVETYPE_DESTROYOBJ: + case OBJECTIVETYPE_COMPFLAGS: + case OBJECTIVETYPE_FAILFLAGS: + case OBJECTIVETYPE_COLLECTOBJ: + case OBJECTIVETYPE_THROWOBJ: + { + struct n64_objectivecmd* srcobj = (struct n64_objectivecmd*)cmd; + struct n64_objectivecmd* dstobj = (struct n64_objectivecmd*)dst; + + PD_CONV_ARRAY(dstobj->cmd0, srcobj->cmd0); + PD_CONV_VAL(dstobj->cmd1, srcobj->cmd1); + + dst += sizeof(struct n64_objectivecmd); + break; + } + case OBJECTIVETYPE_HOLOGRAPH: + { + struct n64_criteria_holograph* srcobj = (struct n64_criteria_holograph*)cmd; + struct criteria_holograph* dstobj = (struct criteria_holograph*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->obj, srcobj->obj); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_holograph); + break; + } + case OBJECTIVETYPE_ENTERROOM: + { + struct n64_criteria_roomentered* srcobj = (struct n64_criteria_roomentered*)cmd; + struct criteria_roomentered* dstobj = (struct criteria_roomentered*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_roomentered); + break; + } + case OBJECTIVETYPE_THROWINROOM: + { + struct n64_criteria_throwinroom* srcobj = (struct n64_criteria_throwinroom*)cmd; + struct criteria_throwinroom* dstobj = (struct criteria_throwinroom*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_throwinroom); + break; + } + case OBJTYPE_BRIEFING: + { + struct n64_briefingobj* srcobj = (struct n64_briefingobj*)cmd; + struct briefingobj* dstobj = (struct briefingobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->type, srcobj->type); + PD_CONV_VAL(dstobj->text, srcobj->text); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct briefingobj); + break; + } + case OBJTYPE_RENAMEOBJ: + { + struct n64_textoverride* srcobj = (struct n64_textoverride*)cmd; + struct textoverride* dstobj = (struct textoverride*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->objoffset, srcobj->objoffset); + PD_CONV_VAL(dstobj->weapon, srcobj->weapon); + PD_CONV_VAL(dstobj->obtaintext, srcobj->obtaintext); + PD_CONV_VAL(dstobj->ownertext, srcobj->ownertext); + PD_CONV_VAL(dstobj->inventorytext, srcobj->inventorytext); + PD_CONV_VAL(dstobj->inventory2text, srcobj->inventory2text); + PD_CONV_VAL(dstobj->pickuptext, srcobj->pickuptext); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + + dst += sizeof(struct textoverride); + break; + } + case OBJTYPE_PADLOCKEDDOOR: + { + struct n64_padlockeddoorobj* srcobj = (struct n64_padlockeddoorobj*)cmd; + struct padlockeddoorobj* dstobj = (struct padlockeddoorobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->lock, srcobj->ptr_lock); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct padlockeddoorobj); + break; + } + case OBJTYPE_TRUCK: + { + struct n64_truckobj* srcobj = (struct n64_truckobj*)cmd; + struct truckobj* dstobj = (struct truckobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->wheelxrot, srcobj->wheelxrot); + PD_CONV_VAL(dstobj->wheelyrot, srcobj->wheelyrot); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + + dst += sizeof(struct truckobj); + break; + } + case OBJTYPE_HELI: + { + struct n64_heliobj* srcobj = (struct n64_heliobj*)cmd; + struct heliobj* dstobj = (struct heliobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->rotoryrot, srcobj->rotoryrot); + PD_CONV_VAL(dstobj->rotoryspeed, srcobj->rotoryspeed); + PD_CONV_VAL(dstobj->rotoryspeedaim, srcobj->rotoryspeedaim); + PD_CONV_VAL(dstobj->rotoryspeedtime, srcobj->rotoryspeedtime); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + + dst += sizeof(struct heliobj); + break; + } + case OBJTYPE_GLASS: + { + struct n64_glassobj* srcobj = (struct n64_glassobj*)cmd; + struct glassobj* dstobj = (struct glassobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + + dst += sizeof(struct glassobj); + break; + } + case OBJTYPE_SAFEITEM: + { + struct n64_safeitemobj* srcobj = (struct n64_safeitemobj*)cmd; + struct safeitemobj* dstobj = (struct safeitemobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->item, srcobj->ptr_item); + PD_CONV_PTR(dstobj->safe, srcobj->ptr_safe); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct safeitemobj); + break; + } + case OBJTYPE_TANK: + { + dst += sizeof(struct n64_tankobj); + break; + } + case OBJTYPE_CAMERAPOS: + { + struct n64_cameraposobj* srcobj = (struct n64_cameraposobj*)cmd; + struct cameraposobj* dstobj = (struct cameraposobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->x, srcobj->x); + PD_CONV_VAL(dstobj->y, srcobj->y); + PD_CONV_VAL(dstobj->z, srcobj->z); + PD_CONV_VAL(dstobj->theta, srcobj->theta); + PD_CONV_VAL(dstobj->verta, srcobj->verta); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + + dst += sizeof(struct cameraposobj); + break; + } + case OBJTYPE_TINTEDGLASS: + { + struct n64_tintedglassobj* srcobj = (struct n64_tintedglassobj*)cmd; + struct tintedglassobj* dstobj = (struct tintedglassobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->xludist, srcobj->xludist); + PD_CONV_VAL(dstobj->opadist, srcobj->opadist); + PD_CONV_VAL(dstobj->opacity, srcobj->opacity); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + PD_CONV_VAL(dstobj->unk64, srcobj->unk64); + + dst += sizeof(struct tintedglassobj); + break; + } + case OBJTYPE_LIFT: + { + struct n64_liftobj* srcobj = (struct n64_liftobj*)cmd; + struct liftobj* dstobj = (struct liftobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_ARRAY(dstobj->pads, srcobj->pads); + for (int k = 0; k < 4; k++) + PD_CONV_PTR(dstobj->doors[k], srcobj->ptr_doors[k]); + PD_CONV_VAL(dstobj->dist, srcobj->dist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->accel, srcobj->accel); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); + PD_CONV_VAL(dstobj->levelcur, srcobj->levelcur); + PD_CONV_VAL(dstobj->levelaim, srcobj->levelaim); + PD_CONV_VAL(dstobj->prevpos, srcobj->prevpos); + + dst += sizeof(struct liftobj); + break; + } + case OBJTYPE_CONDITIONALSCENERY: + { + struct n64_linksceneryobj* srcobj = (struct n64_linksceneryobj*)cmd; + struct linksceneryobj* dstobj = (struct linksceneryobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->trigger, srcobj->ptr_trigger); + PD_CONV_PTR(dstobj->unexp, srcobj->ptr_unexp); + PD_CONV_PTR(dstobj->exp, srcobj->ptr_exp); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct linksceneryobj); + break; + } + case OBJTYPE_BLOCKEDPATH: + { + struct n64_blockedpathobj* srcobj = (struct n64_blockedpathobj*)cmd; + struct blockedpathobj* dstobj = (struct blockedpathobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->blocker, srcobj->ptr_blocker); + PD_CONV_VAL(dstobj->waypoint1, srcobj->waypoint1); + PD_CONV_VAL(dstobj->waypoint2, srcobj->waypoint2); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct blockedpathobj); + break; + } + case OBJTYPE_HOVERBIKE: { + struct n64_hoverbikeobj* srcobj = (struct n64_hoverbikeobj*)cmd; + struct hoverbikeobj* dstobj = (struct hoverbikeobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->hov.type, srcobj->hov.type); + PD_CONV_VAL(dstobj->hov.flags, srcobj->hov.flags); + PD_CONV_VAL(dstobj->hov.bobycur, srcobj->hov.bobycur); + PD_CONV_VAL(dstobj->hov.bobytarget, srcobj->hov.bobytarget); + PD_CONV_VAL(dstobj->hov.bobyspeed, srcobj->hov.bobyspeed); + PD_CONV_VAL(dstobj->hov.yrot, srcobj->hov.yrot); + PD_CONV_VAL(dstobj->hov.bobpitchcur, srcobj->hov.bobpitchcur); + PD_CONV_VAL(dstobj->hov.bobpitchtarget, srcobj->hov.bobpitchtarget); + PD_CONV_VAL(dstobj->hov.bobpitchspeed, srcobj->hov.bobpitchspeed); + PD_CONV_VAL(dstobj->hov.bobrollcur, srcobj->hov.bobrollcur); + PD_CONV_VAL(dstobj->hov.bobrolltarget, srcobj->hov.bobrolltarget); + PD_CONV_VAL(dstobj->hov.bobrollspeed, srcobj->hov.bobrollspeed); + PD_CONV_VAL(dstobj->hov.groundpitch, srcobj->hov.groundpitch); + PD_CONV_VAL(dstobj->hov.y, srcobj->hov.y); + PD_CONV_VAL(dstobj->hov.ground, srcobj->hov.ground); + PD_CONV_VAL(dstobj->hov.prevframe60, srcobj->hov.prevframe60); + PD_CONV_VAL(dstobj->hov.prevgroundframe60, srcobj->hov.prevgroundframe60); + + PD_CONV_ARRAY(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->exreal, srcobj->exreal); + PD_CONV_VAL(dstobj->ezreal, srcobj->ezreal); + PD_CONV_VAL(dstobj->ezreal2, srcobj->ezreal2); + PD_CONV_VAL(dstobj->leanspeed, srcobj->leanspeed); + PD_CONV_VAL(dstobj->leandiff, srcobj->leandiff); + PD_CONV_VAL(dstobj->maxspeedtime240, srcobj->maxspeedtime240); + PD_CONV_ARRAY(dstobj->prevpos, srcobj->prevpos); + PD_CONV_ARRAY(dstobj->rels, srcobj->rels); + PD_CONV_ARRAY(dstobj->speedabs, srcobj->speedabs); + PD_CONV_ARRAY(dstobj->speedrel, srcobj->speedrel); + + dst += sizeof(struct hoverbikeobj); + break; + } + case OBJTYPE_HOVERPROP: + { + struct n64_hoverpropobj* srcobj = (struct n64_hoverpropobj*)cmd; + struct hoverpropobj* dstobj = (struct hoverpropobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->hov.type, srcobj->hov.type); + PD_CONV_VAL(dstobj->hov.flags, srcobj->hov.flags); + PD_CONV_VAL(dstobj->hov.bobycur, srcobj->hov.bobycur); + PD_CONV_VAL(dstobj->hov.bobytarget, srcobj->hov.bobytarget); + PD_CONV_VAL(dstobj->hov.bobyspeed, srcobj->hov.bobyspeed); + PD_CONV_VAL(dstobj->hov.yrot, srcobj->hov.yrot); + PD_CONV_VAL(dstobj->hov.bobpitchcur, srcobj->hov.bobpitchcur); + PD_CONV_VAL(dstobj->hov.bobpitchtarget, srcobj->hov.bobpitchtarget); + PD_CONV_VAL(dstobj->hov.bobpitchspeed, srcobj->hov.bobpitchspeed); + PD_CONV_VAL(dstobj->hov.bobrollcur, srcobj->hov.bobrollcur); + PD_CONV_VAL(dstobj->hov.bobrolltarget, srcobj->hov.bobrolltarget); + PD_CONV_VAL(dstobj->hov.bobrollspeed, srcobj->hov.bobrollspeed); + PD_CONV_VAL(dstobj->hov.groundpitch, srcobj->hov.groundpitch); + PD_CONV_VAL(dstobj->hov.y, srcobj->hov.y); + PD_CONV_VAL(dstobj->hov.ground, srcobj->hov.ground); + PD_CONV_VAL(dstobj->hov.prevframe60, srcobj->hov.prevframe60); + PD_CONV_VAL(dstobj->hov.prevgroundframe60, srcobj->hov.prevgroundframe60); + + dst += sizeof(struct hoverpropobj); + break; + } + case OBJTYPE_FAN: + { + struct n64_fanobj* srcobj = (struct n64_fanobj*)cmd; + struct fanobj* dstobj = (struct fanobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yrotprev, srcobj->yrotprev); + PD_CONV_VAL(dstobj->ymaxspeed, srcobj->ymaxspeed); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->yaccel, srcobj->yaccel); + PD_CONV_VAL(dstobj->on, srcobj->on); + + dst += sizeof(struct fanobj); + break; + } + case OBJTYPE_HOVERCAR: + { + struct n64_hovercarobj* srcobj = (struct n64_hovercarobj*)cmd; + struct hovercarobj* dstobj = (struct hovercarobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnyspeed60, srcobj->turnyspeed60); + PD_CONV_VAL(dstobj->turnxspeed60, srcobj->turnxspeed60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_VAL(dstobj->rotx, srcobj->rotx); + PD_CONV_VAL(dstobj->rotz, srcobj->rotz); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_VAL(dstobj->dead, srcobj->dead); + PD_CONV_VAL(dstobj->deadtimer60, srcobj->deadtimer60); + PD_CONV_VAL(dstobj->sparkstimer60, srcobj->sparkstimer60); + + dst += sizeof(struct hovercarobj); + break; + } + case OBJTYPE_PADEFFECT: + { + struct padeffectobj* srcobj = (struct padeffectobj*)cmd; + struct padeffectobj* dstobj = (struct padeffectobj*)dst; + + convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->effect, srcobj->effect); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + + dst += sizeof(struct padeffectobj); + break; + } + case OBJTYPE_CHOPPER: + { + struct n64_chopperobj* srcobj = (struct n64_chopperobj*)cmd; + struct chopperobj* dstobj = (struct chopperobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnyspeed60, srcobj->turnyspeed60); + PD_CONV_VAL(dstobj->turnxspeed60, srcobj->turnxspeed60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_VAL(dstobj->rotx, srcobj->rotx); + PD_CONV_VAL(dstobj->rotz, srcobj->rotz); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + PD_CONV_VAL(dstobj->weaponsarmed, srcobj->weaponsarmed); + PD_CONV_VAL(dstobj->ontarget, srcobj->ontarget); + PD_CONV_VAL(dstobj->target, srcobj->target); + PD_CONV_VAL(dstobj->attackmode, srcobj->attackmode); + PD_CONV_VAL(dstobj->cw, srcobj->cw); + PD_CONV_VAL(dstobj->vx, srcobj->vx); + PD_CONV_VAL(dstobj->vy, srcobj->vy); + PD_CONV_VAL(dstobj->vz, srcobj->vz); + PD_CONV_VAL(dstobj->power, srcobj->power); + PD_CONV_VAL(dstobj->otx, srcobj->otx); + PD_CONV_VAL(dstobj->oty, srcobj->oty); + PD_CONV_VAL(dstobj->otz, srcobj->otz); + PD_CONV_VAL(dstobj->bob, srcobj->bob); + PD_CONV_VAL(dstobj->bobstrength, srcobj->bobstrength); + PD_CONV_VAL(dstobj->targetvisible, srcobj->targetvisible); + PD_CONV_VAL(dstobj->timer60, srcobj->timer60); + PD_CONV_VAL(dstobj->patroltimer60, srcobj->patroltimer60); + PD_CONV_VAL(dstobj->gunturnyspeed60, srcobj->gunturnyspeed60); + PD_CONV_VAL(dstobj->gunturnxspeed60, srcobj->gunturnxspeed60); + PD_CONV_VAL(dstobj->gunroty, srcobj->gunroty); + PD_CONV_VAL(dstobj->gunrotx, srcobj->gunrotx); + PD_CONV_VAL(dstobj->barrelrotspeed, srcobj->barrelrotspeed); + PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); + PD_CONV_PTR(dstobj->fireslotthing, srcobj->ptr_fireslotthing); + PD_CONV_VAL(dstobj->dead, srcobj->dead); + + dst += sizeof(struct chopperobj); + break; + } + case OBJTYPE_ESCASTEP: + { + struct n64_escalatorobj* srcobj = (struct n64_escalatorobj*)cmd; + struct escalatorobj* dstobj = (struct escalatorobj*)dst; + + convertDefaultObj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->frame, srcobj->frame); + PD_CONV_VAL(dstobj->prevpos, srcobj->prevpos); + + dst += sizeof(struct escalatorobj); + break; + } + } + + cmd = (struct n64_defaultobj*)((u32*)cmd + obj_size(cmd)); + type = cmd->type; + } + + *(u32*)(dst) = htobe32(OBJTYPE_END); + dst += sizeof(u32); + + return (u32)(dst - start); +} + +static uintptr_t convertIntro(u8 *dst, u8 *src) +{ + u8 cmd_size[] = { + 3, // INTROCMD_SPAWN + 4, // INTROCMD_WEAPON + 4, // INTROCMD_AMMO + 8, // INTROCMD_3 + 2, // INTROCMD_4 + 2, // INTROCMD_OUTFIT + 10, // INTROCMD_6 + 3, // INTROCMD_WATCHTIME + 2, // INTROCMD_CREDITOFFSET + 3, // INTROCMD_CASE + 3, // INTROCMD_CASERESPAWN + 2, // INTROCMD_HILL + 1, // the INTROCMD_END constant itself + }; + + s32* dstintro = (s32*)dst; + s32* srcintro = (s32*)src; + + while (true) { + s32 cmd = dstintro[0] = srctodst32(srcintro[0]); + u8 size = cmd_size[*dstintro]; + for (int i = 1; i < size; i++) { + dstintro[i] = srctodst32(srcintro[i]); + } + + dstintro += size; + srcintro += size; + + if (cmd == INTROCMD_END) break; + } + + return (u32)((u8*)dstintro - dst); +} + +static u32 convertPaths(u8 *dst, u8 *src) +{ + struct n64_path* srcpath = (struct n64_path*)src; + struct path* dstpath = (struct path*)dst; + + while (true) { + PD_CONV_PTR(dstpath->pads, srcpath->ptr_pads); + PD_CONV_VAL(dstpath->id, srcpath->id); + PD_CONV_VAL(dstpath->flags, srcpath->flags); + PD_CONV_VAL(dstpath->len, srcpath->len); + + if (srcpath->ptr_pads == 0) break; + + dstpath++; + srcpath++; + } + + // extra pointer for the end marker + return (u32)((u8*)dstpath - dst + sizeof(uintptr_t)); +} + +static u32 convertPads(struct path *dstpaths, u8 *dst, u8 *src, u32 dstpos) +{ + u32 start = dstpos; + s32 *dstpads = (s32*)&dst[dstpos]; + while (dstpaths->pads) { + s32 *pads = (s32*)&src[(uintptr_t)dstpaths->pads]; + dstpaths->pads = (s32*)dstpos; + + while (*pads) { + s32 p = srctoh32(*pads++); + *dstpads++ = p; + dstpos += sizeof(s32); + if (p == -1) break; + } + + dstpaths++; + } + + return dstpos - start; +} + +static u32 convertAiLists(u8* dst, u8* src) +{ + struct n64_ailist* srcailist = (struct n64_ailist*)src; + struct ailist* dstailist = (struct ailist*)dst; + + while (true) { + // at this point these fields are already converted, so we just assign + dstailist->list = srcailist->ptr_list; + dstailist->id = srcailist->id; + + + if (srcailist->ptr_list == 0) break; + + dstailist++; + srcailist++; + } + + return (u32)((u8*)dstailist - dst + sizeof(uintptr_t)); +} + +u32 chraiGetAilistLength(u8 *list); + +static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) +{ + resetMarkers(); + struct n64_ailist *src_ailists = (struct n64_ailist*)&src[src_ofs]; + + // count the lists and pre-convert the fields + int nlists = 0; + for (struct n64_ailist *tmp = src_ailists; tmp->ptr_list; tmp++, nlists++) { + tmp->ptr_list = srctodst32(tmp->ptr_list); + tmp->id = srctodst32(tmp->id); + } + + for (struct n64_ailist *ailist = src_ailists; ailist->ptr_list; ailist++) { + // update the src list pointers here + uintptr_t src_ptr_list = (uintptr_t) ailist->ptr_list; + ailist->ptr_list = (u8*)dstpos; + + // multiple ailists can point to the same list, so we need to check if it was already copied + struct ptrmarker *marker = findPtrMarker(src_ptr_list); + if (marker) { + ailist->ptr_list = marker->ptr_host; + continue; + } + + addMarker(src_ptr_list, dstpos); + + u8 *list = &src[src_ptr_list]; + u32 listsize = chraiGetAilistLength(list); + memcpy(dst + dstpos, list, listsize); + + // align to the next multiple of 4 + dstpos += ((listsize + 3) >> 2) << 2; + } + + return dstpos; +} + +static int convertSetup(u8 *dst, u8 *src, u32 srclen) +{ + struct n64_stagesetup *src_header = (struct n64_stagesetup*)src; + struct stagesetup *dst_header = (struct stagesetup*)dst; + + src_header->ptr_props = srctodst32(src_header->ptr_props); + src_header->ptr_intro = srctodst32(src_header->ptr_intro); + src_header->ptr_ailists = srctodst32(src_header->ptr_ailists); + src_header->ptr_paths = srctodst32(src_header->ptr_paths); + + u32 srcpos = sizeof(*src_header); + u32 dstpos = sizeof(*dst_header); + + srcpos = src_header->ptr_props; + dst_header->props = (u32*) dstpos; + dstpos += convertProps(&dst[dstpos], &src[srcpos]); + + srcpos = src_header->ptr_intro; + dst_header->intro = (s32*)dstpos; + dstpos += convertIntro(&dst[dstpos], &src[srcpos]); + + // write the lists bytecodes before the ailists entries + dstpos = convertLists(dst, src, dstpos, src_header->ptr_ailists); + + srcpos = src_header->ptr_ailists; + dst_header->ailists = (struct ailist*)dstpos; + dstpos += convertAiLists(&dst[dstpos], &src[srcpos]); + + srcpos = src_header->ptr_paths; + dst_header->paths = (struct path*) dstpos; + dstpos += convertPaths(&dst[dstpos], &src[srcpos]); + + dstpos += convertPads(&dst[(uintptr_t)dst_header->paths], dst, src, dstpos); + + return dstpos; +} + +u8 *preprocessSetupFile(u8 *data, u32 size, u32 *outSize) { + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_SETUP); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); + + u32 newSize = convertSetup(dst, data, size); + + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a model file, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); + + *outSize = newSize; + + return 0; +} diff --git a/port/src/preprocess/filetiles.c b/port/src/preprocess/filetiles.c new file mode 100644 index 000000000..ed63c416a --- /dev/null +++ b/port/src/preprocess/filetiles.c @@ -0,0 +1,107 @@ +#include +#include +#include + +#include "common.h" +#include "romdata.h" +#include "system.h" + + +struct tile { + u8 type; + u8 numvertices; + u16 flags; + u16 floortype; + u8 xmin; + u8 ymin; + u8 zmin; + u8 xmax; + u8 ymax; + u8 zmax; + u16 floorcol; +}; + +u32 convertTiles(u8 *dst, u8 *src, size_t srclen) +{ + int num_rooms = srctoh32(*(u32 *) src); + + size_t src_ptr_table_len = (num_rooms + 1) * 4; + size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(u32); + + u32 *src_offsets = (u32 *) &src[4]; + + size_t data_len = srclen - src_ptr_table_len - 4; + + *(u32 *) dst = htodst32(num_rooms); + + u32 *dst_offsets = (u32 *) (dst + sizeof(u32)); + u32 cur_dst_offset = dst_ptr_table_len + sizeof(u32); + + u32 cur_src_offset = srctoh32(src_offsets[0]); + u32 end_src_offset = srctoh32(src_offsets[num_rooms]); + int room = 0; + + while (1) { + // Check if this is a new room and write the pointer offset if so + while (room < (num_rooms + 1) && srctoh32(src_offsets[room]) == cur_src_offset) { + dst_offsets[room] = htodst32(cur_dst_offset); + room++; + } + + if (cur_src_offset >= end_src_offset) { + break; + } + + // Write tile data + struct tile *n64tile = (struct tile *) &src[cur_src_offset]; + struct tile hosttile; + + hosttile.type = n64tile->type; + hosttile.numvertices = n64tile->numvertices; + hosttile.flags = srctodst16(n64tile->flags); + hosttile.floortype = srctodst16(n64tile->floortype); + hosttile.xmin = n64tile->xmin; + hosttile.ymin = n64tile->ymin; + hosttile.zmin = n64tile->zmin; + hosttile.xmax = n64tile->xmax; + hosttile.ymax = n64tile->ymax; + hosttile.zmax = n64tile->zmax; + hosttile.floorcol = srctodst16(n64tile->floorcol); + + memcpy(&dst[cur_dst_offset], &hosttile, sizeof(struct tile)); + + cur_dst_offset += sizeof(struct tile); + cur_src_offset += sizeof(struct tile); + + // Write tile vertices + for (int i = 0; i < hosttile.numvertices; i++) { + *(s16 *) &dst[cur_dst_offset + 0] = srctodst16(*(s16 *) &src[cur_src_offset + 0]); + *(s16 *) &dst[cur_dst_offset + 2] = srctodst16(*(s16 *) &src[cur_src_offset + 2]); + *(s16 *) &dst[cur_dst_offset + 4] = srctodst16(*(s16 *) &src[cur_src_offset + 4]); + cur_dst_offset += 6; + cur_src_offset += 6; + } + } + + return ALIGN16(cur_dst_offset); +} + +u8 *preprocessTilesFile(u8 *data, u32 size, u32 *outSize) +{ + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_TILES); + u8 *dst = sysMemZeroAlloc(newSizeEstimated); + + u32 newSize = convertTiles(dst, data, size); + + if (newSize > newSizeEstimated) { + sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a tiles file, size %d newsize %d", size, newSize); + exit(EXIT_FAILURE); + } + + memcpy(data, dst, newSize); + sysMemFree(dst); + + *outSize = newSize; + + return 0; +} diff --git a/port/src/preprocess.c b/port/src/preprocess/preprocess.c similarity index 72% rename from port/src/preprocess.c rename to port/src/preprocess/preprocess.c index 791008ca3..d27d398e8 100644 --- a/port/src/preprocess.c +++ b/port/src/preprocess/preprocess.c @@ -14,30 +14,7 @@ #include "romdata.h" #include "mod.h" #include "system.h" - -static inline f32 swapF32(f32 x) { *(u32 *)&x = PD_BE32(*(u32 *)&x); return x; } -static inline u32 swapU32(u32 x) { return PD_BE32(x); } -static inline s32 swapS32(s32 x) { return PD_BE32(x); } -static inline u16 swapU16(u16 x) { return PD_BE16(x); } -static inline s16 swapS16(s16 x) { return PD_BE16(x); } -static inline void *swapPtr(void **x) { return (void *)PD_BEPTR((uintptr_t)x); } -static inline struct coord swapCrd(struct coord crd) { crd.x = swapF32(crd.x); crd.y = swapF32(crd.y); crd.z = swapF32(crd.z); return crd; } -static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } - -#define PD_SWAP_VAL(x) x = _Generic((x), \ - f32: swapF32, \ - u32: swapU32, \ - s32: swapS32, \ - u16: swapU16, \ - s16: swapS16, \ - struct coord: swapCrd, \ - default: swapUnk \ -)(x) - -#define PD_SWAP_PTR(x) x = swapPtr((void *)(x)) - -#define PD_PTR_BASE(x, b) (void *)((u8 *)b + (uintptr_t)x) -#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (uintptr_t)x) +#include "common.h" // HACK: to prevent double-swapping stuff, flag swapped offsets in a bitmap @@ -275,77 +252,3 @@ u8* preprocessTexturesList(u8* data, u32 size, u32* outSize) } return 0; } - -void preprocessBgSection1Header(u8 *data, u32 size) -{ - u32 *header = (u32 *)data; - PD_SWAP_VAL(header[0]); // inflatedsize - PD_SWAP_VAL(header[1]); // section1size - PD_SWAP_VAL(header[2]); // primcompsize -} - -void preprocessBgSection2Header(u8 *data, u32 size) -{ - u16 *header = (u16 *)data; - PD_SWAP_VAL(header[0]); // inflatedsize - PD_SWAP_VAL(header[1]); // section2compsize -} - -void preprocessBgSection2(u8 *data, u32 size) -{ - // section2 is a texture id list - u16 *section2 = (u16 *)data; - for (s32 i = 0; i < size; ++i) { - PD_SWAP_VAL(section2[i]); - } -} - -void preprocessBgSection3Header(u8 *data, u32 size) -{ - u16 *header = (u16 *)data; - PD_SWAP_VAL(header[0]); - PD_SWAP_VAL(header[1]); -} - -void preprocessBgSection3(u8 *data, u32 size) -{ - // room bounding boxes, 6x s16 per room - s16 *bbox = (s16 *)data; - for (s32 i = 1; i < g_Vars.roomcount; ++i) { - PD_SWAP_VAL(*bbox); ++bbox; - PD_SWAP_VAL(*bbox); ++bbox; - PD_SWAP_VAL(*bbox); ++bbox; - PD_SWAP_VAL(*bbox); ++bbox; - PD_SWAP_VAL(*bbox); ++bbox; - PD_SWAP_VAL(*bbox); ++bbox; - } - - // gfxdatalen list - u16 *gfxdatalen = (u16 *)bbox; - for (s32 i = 1; i < g_Vars.roomcount; ++i) { - PD_SWAP_VAL(*gfxdatalen); ++gfxdatalen; - } -} - -void preprocessBgLights(u8 *data, u32 ofs) -{ - struct light *lbase = (void *)data; - if (!lbase) { - return; - } - - for (s32 i = 0; i < g_Vars.roomcount; ++i) { - if (g_Rooms[i].numlights) { - struct light *lit = &lbase[g_Rooms[i].lightindex]; - for (s32 j = 0; j < g_Rooms[i].numlights; ++j, ++lit) { - PD_SWAP_VAL(lit->colour); - PD_SWAP_VAL(lit->roomnum); - for (s32 k = 0; k < ARRAYCOUNT(lit->bbox); ++k) { - PD_SWAP_VAL(lit->bbox[k].x); - PD_SWAP_VAL(lit->bbox[k].y); - PD_SWAP_VAL(lit->bbox[k].z); - } - } - } - } -} diff --git a/port/src/preprocess/segaudio.c b/port/src/preprocess/segaudio.c new file mode 100644 index 000000000..2e03f2f00 --- /dev/null +++ b/port/src/preprocess/segaudio.c @@ -0,0 +1,426 @@ +#include +#include +#include + +#include "libaudio.h" + +#include "common.h" +#include "system.h" + +struct generic_adpcm_book { + s32 order; + s32 npredictors; + s16 book[128]; +}; + +struct generic_adpcm_loop { + u32 start; + u32 end; + u32 count; + s16 state[16]; +}; + +struct generic_raw_loop { + u32 start; + u32 end; + u32 count; +}; + +struct generic_envelope { + s32 attackTime; + s32 decayTime; + s32 releaseTime; + u8 attackVolume; + u8 decayVolume; +}; + +struct generic_keymap { + u8 velocityMin; + u8 velocityMax; + u8 keyMin; + u8 keyMax; + u8 keyBase; + s8 detune; +}; + +struct n64_adpcm_waveinfo { + u32 loop; // ptr to struct generic_adpcm_loop + u32 book; // ptr to struct generic_adpcm_book +}; + +struct host_adpcm_waveinfo { + uintptr_t loop; // ptr to struct generic_adpcm_loop + uintptr_t book; // ptr to struct generic_adpcm_book +}; + +struct n64_raw_waveinfo { + u32 loop; // ptr to struct generic_raw_loop +}; + +struct host_raw_waveinfo { + uintptr_t loop; // ptr to struct generic_raw_loop +}; + +struct n64_wavetable { + u32 base; + s32 len; + u8 type; + u8 flags; + union { + struct n64_adpcm_waveinfo adpcmWave; + struct n64_raw_waveinfo rawWave; + } waveInfo; +}; + +struct host_wavetable { + uintptr_t base; + s32 len; + u8 type; + u8 flags; + union { + struct host_adpcm_waveinfo adpcmWave; + struct host_raw_waveinfo rawWave; + } waveInfo; +}; + +struct n64_sound { + u32 envelope; // ptr to struct generic_envelope + u32 keyMap; // ptr to struct generic_keymap + u32 wavetable; // ptr to struct n64_wavetable + u8 samplePan; + u8 sampleVolume; + u8 flags; +}; + +struct host_sound { + uintptr_t envelope; // ptr to struct generic_envelope + uintptr_t keyMap; // ptr to struct generic_keymap + uintptr_t wavetable; // ptr to struct host_wavetable + u8 samplePan; + u8 sampleVolume; + u8 flags; +}; + +struct n64_instrument { + u8 volume; + u8 pan; + u8 priority; + u8 flags; + u8 tremType; + u8 tremRate; + u8 tremDepth; + u8 tremDelay; + u8 vibType; + u8 vibRate; + u8 vibDepth; + u8 vibDelay; + s16 bendRange; + s16 soundCount; + u32 soundArray[1]; // ptr to struct n64_sound +}; + +struct host_instrument { + u8 volume; + u8 pan; + u8 priority; + u8 flags; + u8 tremType; + u8 tremRate; + u8 tremDepth; + u8 tremDelay; + u8 vibType; + u8 vibRate; + u8 vibDepth; + u8 vibDelay; + s16 bendRange; + s16 soundCount; + uintptr_t soundArray[1]; // ptr to struct host_sound +}; + +struct n64_bank { + s16 instCount; + u8 flags; + u8 pad; + s32 sampleRate; + u32 percussion; // ptr to struct n64_instrument + u32 instArray[1]; // ptr to struct n64_instrument +}; + +struct host_bank { + s16 instCount; + u8 flags; + u8 pad; + s32 sampleRate; + uintptr_t percussion; // ptr to struct host_instrument + uintptr_t instArray[1]; // ptr to struct host_instrument +}; + +struct n64_bankfile { + s16 revision; + s16 bankCount; + u32 bankArray[1]; // ptr to struct n64_bank +}; + +struct host_bankfile { + s16 revision; + s16 bankCount; + uintptr_t bankArray[1]; // ptr to struct host_bank +}; + +// only proceeds to convert the next item if it's not already converted +#define AL_NEXT_ITEM(field, func) { \ + struct ptrmarker *marker = findPtrMarker(srcpos); \ + if (marker == NULL) { \ + field = htodst32(dstpos); \ + addMarker(srcpos, field); \ + dstpos = func(dst, dstpos, src, srcpos); \ + } else { \ + field = marker->ptr_host; } \ +} + +static int convertAudioEnvelope(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct generic_envelope *n64_envelope = (struct generic_envelope *) &src[srcpos]; + struct generic_envelope *host_envelope = (struct generic_envelope *) &dst[dstpos]; + + dstpos += sizeof(struct generic_envelope); + + host_envelope->attackTime = srctodst32(n64_envelope->attackTime); + host_envelope->decayTime = srctodst32(n64_envelope->decayTime); + host_envelope->releaseTime = srctodst32(n64_envelope->releaseTime); + host_envelope->attackVolume = n64_envelope->attackVolume; + host_envelope->decayVolume = n64_envelope->decayVolume; + + return dstpos; +} + +static int convertAudioKeyMap(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct generic_keymap *n64_keymap = (struct generic_keymap *) &src[srcpos]; + struct generic_keymap *host_keymap = (struct generic_keymap *) &dst[dstpos]; + + dstpos += sizeof(struct generic_keymap); + + host_keymap->velocityMin = n64_keymap->velocityMin; + host_keymap->velocityMax = n64_keymap->velocityMax; + host_keymap->keyMin = n64_keymap->keyMin; + host_keymap->keyMax = n64_keymap->keyMax; + host_keymap->keyBase = n64_keymap->keyBase; + host_keymap->detune = n64_keymap->detune; + + return dstpos; +} + +static int convertAudioAdpcmLoop(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct generic_adpcm_loop *n64_loop = (struct generic_adpcm_loop *) &src[srcpos]; + struct generic_adpcm_loop *host_loop = (struct generic_adpcm_loop *) &dst[dstpos]; + + dstpos += sizeof(struct generic_adpcm_loop); + + host_loop->start = srctodst32(n64_loop->start); + host_loop->end = srctodst32(n64_loop->end); + host_loop->count = srctodst32(n64_loop->count); + + for (int i = 0; i < ARRAYCOUNT(host_loop->state); i++) { + host_loop->state[i] = srctodst16(n64_loop->state[i]); + } + + return dstpos; +} + +static int convertAudioAdpcmBook(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct generic_adpcm_book *n64_book = (struct generic_adpcm_book *) &src[srcpos]; + struct generic_adpcm_book *host_book = (struct generic_adpcm_book *) &dst[dstpos]; + + dstpos += sizeof(struct generic_adpcm_book); + + host_book->order = srctodst32(n64_book->order); + host_book->npredictors = srctodst32(n64_book->npredictors); + + for (int i = 0; i < ARRAYCOUNT(host_book->book); i++) { + host_book->book[i] = srctodst16(n64_book->book[i]); + } + + return dstpos; +} + +static int convertAudioRawLoop(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct generic_raw_loop *n64_loop = (struct generic_raw_loop *) &src[srcpos]; + struct generic_raw_loop *host_loop = (struct generic_raw_loop *) &dst[dstpos]; + + dstpos += sizeof(struct generic_raw_loop); + + host_loop->start = srctodst32(n64_loop->start); + host_loop->end = srctodst32(n64_loop->end); + host_loop->count = srctodst32(n64_loop->count); + + return dstpos; +} + +static int convertAudioWaveTable(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct n64_wavetable *n64_wavetable = (struct n64_wavetable *) &src[srcpos]; + struct host_wavetable *host_wavetable = (struct host_wavetable *) &dst[dstpos]; + + dstpos += sizeof(struct host_wavetable); + + host_wavetable->base = srctodst32(n64_wavetable->base); + host_wavetable->len = srctodst32(n64_wavetable->len); + host_wavetable->type = n64_wavetable->type; + host_wavetable->flags = n64_wavetable->flags; + + if (host_wavetable->type == AL_ADPCM_WAVE) { + if (n64_wavetable->waveInfo.adpcmWave.loop) { + srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.loop); + AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.loop, convertAudioAdpcmLoop); + } else { + host_wavetable->waveInfo.adpcmWave.loop = 0; + } + + if (n64_wavetable->waveInfo.adpcmWave.book) { + srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.book); + AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.book, convertAudioAdpcmBook); + } else { + host_wavetable->waveInfo.adpcmWave.book = 0; + } + } else if (host_wavetable->type == AL_RAW16_WAVE) { + if (n64_wavetable->waveInfo.rawWave.loop) { + srcpos = srctoh32(n64_wavetable->waveInfo.rawWave.loop); + AL_NEXT_ITEM(host_wavetable->waveInfo.rawWave.loop, convertAudioRawLoop); + } else { + host_wavetable->waveInfo.rawWave.loop = 0; + } + } + + return dstpos; +} + +static int convertAudioSound(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct n64_sound *n64_sound = (struct n64_sound *) &src[srcpos]; + struct host_sound *host_sound = (struct host_sound *) &dst[dstpos]; + + dstpos += sizeof(struct host_sound); + + if (n64_sound->envelope) { + srcpos = srctoh32(n64_sound->envelope); + AL_NEXT_ITEM(host_sound->envelope, convertAudioEnvelope); + } else { + host_sound->envelope = 0; + } + + if (n64_sound->keyMap) { + srcpos = srctoh32(n64_sound->keyMap); + AL_NEXT_ITEM(host_sound->keyMap, convertAudioKeyMap); + } else { + host_sound->keyMap = 0; + } + + if (n64_sound->wavetable) { + srcpos = srctoh32(n64_sound->wavetable); + AL_NEXT_ITEM(host_sound->wavetable, convertAudioWaveTable); + } else { + host_sound->wavetable = 0; + } + + host_sound->samplePan = n64_sound->samplePan; + host_sound->sampleVolume = n64_sound->sampleVolume; + host_sound->flags = n64_sound->flags; + + return dstpos; +} + +static int convertAudioInstrument(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct n64_instrument *n64_instrument = (struct n64_instrument *) &src[srcpos]; + struct host_instrument *host_instrument = (struct host_instrument *) &dst[dstpos]; + int soundCount = srctoh16(n64_instrument->soundCount); + + host_instrument->volume = n64_instrument->volume; + host_instrument->pan = n64_instrument->pan; + host_instrument->priority = n64_instrument->priority; + host_instrument->flags = n64_instrument->flags; + host_instrument->tremType = n64_instrument->tremType; + host_instrument->tremRate = n64_instrument->tremRate; + host_instrument->tremDepth = n64_instrument->tremDepth; + host_instrument->tremDelay = n64_instrument->tremDelay; + host_instrument->vibType = n64_instrument->vibType; + host_instrument->vibRate = n64_instrument->vibRate; + host_instrument->vibDepth = n64_instrument->vibDepth; + host_instrument->vibDelay = n64_instrument->vibDelay; + host_instrument->bendRange = srctodst16(n64_instrument->bendRange); + host_instrument->soundCount = htodst16(soundCount); + + dstpos = dstpos + sizeof(struct host_instrument) + sizeof(uintptr_t) * (soundCount - 1); + + for (int i = 0; i < soundCount; i++) { + srcpos = srctoh32(n64_instrument->soundArray[i]); + AL_NEXT_ITEM(host_instrument->soundArray[i], convertAudioSound); + } + + return dstpos; +} + +static int convertAudioBank(u8 *dst, int dstpos, u8 *src, int srcpos) +{ + struct n64_bank *n64_bank = (struct n64_bank *) &src[srcpos]; + struct host_bank *host_bank = (struct host_bank *) &dst[dstpos]; + int instCount = srctoh16(n64_bank->instCount); + + host_bank->instCount = htodst16(instCount); + host_bank->flags = n64_bank->flags; + host_bank->pad = n64_bank->pad; + host_bank->sampleRate = srctodst32(n64_bank->sampleRate); + + dstpos = dstpos + sizeof(struct host_bank) + sizeof(uintptr_t) * (instCount - 1); + + if (n64_bank->percussion) { + srcpos = srctoh32(n64_bank->percussion); + AL_NEXT_ITEM(host_bank->percussion, convertAudioInstrument); + } else { + host_bank->percussion = 0; + } + + for (int i = 0; i < instCount; i++) { + srcpos = srctoh32(n64_bank->instArray[i]); + AL_NEXT_ITEM(host_bank->instArray[i], convertAudioInstrument); + } + + return dstpos; +} + +static int convertAudioBankFile(u8 *dst, u8 *src) +{ + struct n64_bankfile *n64_bankfile = (struct n64_bankfile *)src; + struct host_bankfile *host_bankfile = (struct host_bankfile *)dst; + int bankCount = srctoh16(n64_bankfile->bankCount); + + host_bankfile->revision = srctodst16(n64_bankfile->revision); + host_bankfile->bankCount = htodst16(bankCount); + + + u32 dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); + + for (int i = 0; i < bankCount; i++) { + host_bankfile->bankArray[i] = htodst32(dstpos); + u32 srcpos = srctoh32(n64_bankfile->bankArray[i]); + dstpos = convertAudioBank(dst, dstpos, src, srcpos); + } + + return dstpos; +} + +u8 *preprocessALBankFile(u8 *src, u32 size, u32 *outSize) +{ + resetMarkers(); + u32 dstlen = size * 3; + u8 *dst = sysMemZeroAlloc(dstlen); + + *outSize = convertAudioBankFile(dst, src); + *outSize = ALIGN16(*outSize); + + return dst; +} diff --git a/port/src/preprocess/segfonts.c b/port/src/preprocess/segfonts.c new file mode 100644 index 000000000..b2f9ab1b8 --- /dev/null +++ b/port/src/preprocess/segfonts.c @@ -0,0 +1,122 @@ +#include +#include +#include +#include +#include +#include "common.h" +#include "system.h" + +struct n64fontchar { + u8 index; + s8 baseline; + u8 height; + u8 width; + s32 kerningindex; + u32 pixeldata; +}; + +struct hostfontchar { + u8 index; + s8 baseline; + u8 height; + u8 width; + s32 kerningindex; + uintptr_t pixeldata; +}; + +struct n64fontcharjpn { + u16 index; + s8 baseline; + u8 height; + u8 width; + s16 kerningindex; + u32 pixeldata; +}; + +struct hostfontcharjpn { + u16 index; + s8 baseline; + u8 height; + u8 width; + s16 kerningindex; + uintptr_t pixeldata; +}; + +struct fontdef { + const char *name; + u32 offsets[3]; + int pal_extra_chars; +}; + +u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) +{ + int num_chars = 94; +#if VERSION == VERSION_PAL_FINAL + // PAL has more characters in these fonts + extern u8* _fonthandelgothicsmSegmentRomStart; + extern u8* _fonthandelgothicxsSegmentRomStart; + extern u8* _fonthandelgothicmdSegmentRomStart; + if (src == _fonthandelgothicsmSegmentRomStart + || src == _fonthandelgothicxsSegmentRomStart + || src == _fonthandelgothicmdSegmentRomStart) { + numchars = 135; + } +#endif + + size_t dstlen = srclen - (num_chars * sizeof(struct n64fontchar)) + (num_chars * sizeof(struct hostfontchar)) + 0x20; + u8* dst = sysMemZeroAlloc(dstlen); + + // Kerning table + s32 *src_kerning_table = (s32 *)src; + s32 *dst_kerning_table = (s32 *)dst; + + for (int i = 0; i < 13 * 13; i++) { + dst_kerning_table[i] = srctodst32(src_kerning_table[i]); + } + + u32 src_offset = ALIGN(13 * 13 * 4, sizeof(u32)); + u32 dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); + + // Character table +#if VERSION == VERSION_JPN_FINAL + struct n64fontcharjpn *src_char_table = (struct n64fontcharjpn *) &src[src_offset]; + struct hostfontcharjpn *dst_char_table = (struct hostfontcharjpn *) &dst[dst_offset]; + u32 diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); + + for (int i = 0; i < num_chars; i++) { + dst_char_table[i].index = srctodst16(src_char_table[i].index); + dst_char_table[i].baseline = src_char_table[i].baseline; + dst_char_table[i].height = src_char_table[i].height; + dst_char_table[i].width = src_char_table[i].width; + dst_char_table[i].kerningindex = srctodst16(src_char_table[i].kerningindex); + dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? srctodst32(src_char_table[i].pixeldata) + diff : 0; + } + + src_offset += num_chars * sizeof(struct n64fontcharjpn); + dst_offset += num_chars * sizeof(struct hostfontcharjpn); +#else + struct n64fontchar *src_char_table = (struct n64fontchar *) &src[src_offset]; + struct hostfontchar *dst_char_table = (struct hostfontchar *) &dst[dst_offset]; + u32 diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); + + for (int i = 0; i < num_chars; i++) { + dst_char_table[i].index = src_char_table[i].index; + dst_char_table[i].baseline = src_char_table[i].baseline; + dst_char_table[i].height = src_char_table[i].height; + dst_char_table[i].width = src_char_table[i].width; + dst_char_table[i].kerningindex = srctodst32(src_char_table[i].kerningindex); + dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? srctodst32(src_char_table[i].pixeldata) + diff : 0; + } + + src_offset += num_chars * sizeof(struct n64fontchar); + dst_offset += num_chars * sizeof(struct hostfontchar); +#endif + + // Pixel data + u32 len = srclen - src_offset; + memcpy(&dst[dst_offset], &src[src_offset], len); + + if (outSize) *outSize = ALIGN16(dst_offset + len); + + return dst; +} diff --git a/port/src/preprocess/setups_decl.h b/port/src/preprocess/setups_decl.h new file mode 100644 index 000000000..e78afd62b --- /dev/null +++ b/port/src/preprocess/setups_decl.h @@ -0,0 +1,642 @@ +#ifndef _IN_SETUP_DECL +#define _IN_SETUP_DECL + +#include "common.h" + + +struct n64_stagesetup { + u32 ptr_waypoints; + u32 ptr_waygroups; + u32 ptr_cover; + u32 ptr_intro; + u32 ptr_props; + u32 ptr_paths; + u32 ptr_ailists; + u32 ptr_padfiledata; +}; + + +struct n64_coord { + f32 x; + f32 y; + f32 z; +}; + +struct n64_defaultobj { + u16 extrascale; + u8 hidden2; + u8 type; + s16 modelnum; + s16 pad; + u32 flags; + u32 flags2; + u32 flags3; + u32 ptr_prop; + u32 ptr_model; + f32 realrot[3][3]; + u32 hidden; + union { + u32 ptr_geotilef; + u32 ptr_geoblock; + u32 ptr_geocyl; + u32 ptr_unkgeo; + }; + union { + u32 ptr_projectile; + u32 ptr_embedment; + }; + s16 damage; + s16 maxdamage; + u8 shadecol[4]; + u8 nextcol[4]; + u16 floorcol; + s8 geocount; + s8 _pad_; +}; + +struct n64_doorobj { + struct n64_defaultobj base; + f32 maxfrac; + f32 perimfrac; + f32 accel; + f32 decel; + f32 maxspeed; + u16 doorflags; + u16 doortype; + u32 keyflags; + s32 autoclosetime; + f32 frac; + f32 fracspeed; + s8 mode; + s8 glasshits; + s16 fadealpha; + s16 xludist; + s16 opadist; + struct n64_coord startpos; + f32 mtx98[3][3]; + u32 ptr_sibling; + s32 lastopen60; + s16 portalnum; + s8 soundtype; + s8 fadetime60; + s32 lastcalc60; + u8 laserfade; + u8 unusedmaybe[3]; + u8 shadeinfo1[4]; + u8 shadeinfo2[4]; + u8 actual1; + u8 actual2; + u8 extra1; + u8 extra2; +}; + +struct n64_doorscaleobj { + u32 unk00; + s32 scale; +}; + +struct n64_keyobj { + struct n64_defaultobj base; + u32 keyflags; +}; + +struct n64_alarmobj { + struct n64_defaultobj base; +}; + +struct n64_cctvobj { + struct n64_defaultobj base; + + s16 lookatpadnum; + s16 toleft; + //Mtxf camrotm; + f32 m[4][4]; + f32 yzero; + f32 yrot; + f32 yleft; + f32 yright; + f32 yspeed; + f32 ymaxspeed; + s32 seebondtime60; + f32 maxdist; + f32 xzero; +}; + +struct n64_ammocrateobj { + struct n64_defaultobj base; + s32 ammotype; +}; + +struct n64_gset { + u8 weaponnum; + u8 unk0639; + u8 unk063a; + u8 weaponfunc; +}; + +struct n64_weaponobj { + struct n64_defaultobj base; + + union { + struct n64_gset gset; + struct { + u8 weaponnum; + s8 unk5d; + s8 unk5e; + u8 gunfunc; + }; + }; + + s8 fadeouttimer60; + s8 dualweaponnum; + + union { + s16 timer240; + s16 team; + }; + + u32 ptr_dualweapon; +}; + +struct n64_packedchr { + s16 chrindex; + s8 unk02; + s8 typenum; + u32 spawnflags; + s16 chrnum; + u16 padnum; + u8 bodynum; + s8 headnum; + u16 ailistnum; + u16 padpreset; + u16 chrpreset; + u16 hearscale; + u16 viewdist; + u32 flags; + u32 flags2; + u8 team; + u8 squadron; + s16 chair; + u32 convtalk; + u8 tude; + u8 naturalanim; + u8 yvisang; + u8 teamscandist; +}; + +struct n64_tvscreen { + u32 ptr_cmdlist; + u16 offset; + s16 pause60; + u32 ptr_tconfig; + f32 rot; + f32 xscale; + f32 xscalefrac; + f32 xscaleinc; + f32 xscaleold; + f32 xscalenew; + f32 yscale; + f32 yscalefrac; + f32 yscaleinc; + f32 yscaleold; + f32 yscalenew; + f32 xmid; + f32 xmidfrac; + f32 xmidinc; + f32 xmidold; + f32 xmidnew; + f32 ymid; + f32 ymidfrac; + f32 ymidinc; + f32 ymidold; + f32 ymidnew; + u8 red; + u8 redold; + u8 rednew; + u8 green; + u8 greenold; + u8 greennew; + u8 blue; + u8 blueold; + u8 bluenew; + u8 alpha; + u8 alphaold; + u8 alphanew; + f32 colfrac; + f32 colinc; +}; + +struct n64_singlemonitorobj { + struct n64_defaultobj base; + struct n64_tvscreen screen; + s16 owneroffset; + s8 ownerpart; + u8 imagenum; +}; + +struct n64_multimonitorobj { + struct n64_defaultobj base; + struct n64_tvscreen screens[4]; + u8 imagenums[4]; +}; + +struct n64_hangingmonitorsobj { + struct n64_defaultobj base; +}; + +struct n64_autogunobj { + struct n64_defaultobj base; + s16 targetpad; + s8 firing; + u8 firecount; + f32 yzero; + f32 ymaxleft; + f32 ymaxright; + f32 yrot; + f32 yspeed; + f32 xzero; + f32 xrot; + f32 xspeed; + f32 maxspeed; + f32 aimdist; + f32 barrelspeed; + f32 barrelrot; + s32 lastseebond60; + s32 lastaimbond60; + s32 allowsoundframe; + u32 ptr_beam; + f32 shotbondsum; + u32 ptr_target; + u8 targetteam; + u8 ammoquantity; + s16 nextchrtest; +}; + +struct n64_linkgunsobj { + u32 unk00; + s16 offset1; + s16 offset2; +}; + +struct n64_debrisobj { + struct n64_defaultobj base; +}; + +struct n64_hatobj { + struct n64_defaultobj base; +}; + +struct n64_grenadeprobobj { // objtype 0x12 + u32 unk00; + s16 chrnum; + u16 probability; +}; + +struct n64_linkliftdoorobj { + u32 unk00; + u32 ptr_door; + u32 ptr_lift; + u32 ptr_next; + s32 stopnum; +}; + +struct n64_multiammocrateslot { + u16 modelnum; + u16 quantity; +}; + +struct n64_multiammocrateobj { + struct n64_defaultobj base; + struct n64_multiammocrateslot slots[19]; +}; + +struct n64_shieldobj { + struct n64_defaultobj base; + f32 initialamount; + f32 amount; + u32 unk64; +}; + +struct n64_tag { + u32 identifier; + u16 tagnum; + s16 cmdoffset; + u32 ptr_next; + u32 ptr_obj; +}; + +struct n64_objective { + u32 unk00; + s32 index; + u32 text; + u16 unk0c; + u8 flags; + s8 difficulties; +}; + +struct n64_stdobjective { + u32 cmd; +}; + +struct n64_objectivecmd { + u8 cmd0[4]; + u32 cmd1; +}; + +struct n64_briefingobj { + u32 unk00; + u32 type; + u32 text; + u32 ptr_next; +}; + +struct n64_padlockeddoorobj { + u32 unk00; + u32 ptr_door; + u32 ptr_lock; + u32 ptr_next; +}; + +struct n64_truckobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 speed; + f32 wheelxrot; + f32 wheelyrot; + f32 speedaim; + f32 speedtime60; + f32 turnrot60; + f32 roty; + u32 ptr_path; + s32 nextstep; +}; + +struct n64_tankobj { + u8 _pad_[128]; +}; + +struct n64_heliobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 rotoryrot; + f32 rotoryspeed; + f32 rotoryspeedaim; + f32 rotoryspeedtime; + f32 speed; + f32 speedaim; + f32 speedtime60; + f32 yrot; + u32 ptr_path; + s32 nextstep; +}; + +struct n64_glassobj { + struct n64_defaultobj base; + s16 portalnum; + s16 _pad_; +}; + +struct n64_safeobj { + struct n64_defaultobj base; +}; + +struct n64_safeitemobj { + u32 unk00; + u32 ptr_item; + u32 ptr_safe; + u32 ptr_door; + u32 ptr_next; +}; + +struct n64_cameraposobj { + s32 type; + f32 x; + f32 y; + f32 z; + f32 theta; + f32 verta; + s32 pad; +}; + +struct n64_tintedglassobj { + struct n64_defaultobj base; + s16 xludist; + s16 opadist; + s16 opacity; + s16 portalnum; + f32 unk64; +}; + +struct n64_liftobj { + struct n64_defaultobj base; + s16 pads[4]; + u32 ptr_doors[4]; + f32 dist; + f32 speed; + f32 accel; + f32 maxspeed; + s8 soundtype; + s8 levelcur; + s8 levelaim; + s8 _pad_; + struct n64_coord prevpos; +}; + +struct n64_linksceneryobj { + u32 unk00; + u32 ptr_trigger; + u32 ptr_unexp; + u32 ptr_exp; + u32 ptr_next; +}; + +struct n64_blockedpathobj { + u32 unk00; + u32 ptr_blocker; + s16 waypoint1; + s16 waypoint2; + u32 ptr_next; +}; + +struct n64_hov { + u8 type; + u8 flags; + s16 _pad_; + f32 bobycur; + f32 bobytarget; + f32 bobyspeed; + f32 yrot; + f32 bobpitchcur; + f32 bobpitchtarget; + f32 bobpitchspeed; + f32 bobrollcur; + f32 bobrolltarget; + f32 bobrollspeed; + f32 groundpitch; + f32 y; + f32 ground; + s32 prevframe60; + s32 prevgroundframe60; +}; + +struct n64_hoverbikeobj { + struct n64_defaultobj base; + struct n64_hov hov; + f32 speed[2]; + f32 prevpos[2]; + f32 w; + f32 rels[2]; + f32 exreal; + f32 ezreal; + f32 ezreal2; + f32 leanspeed; + f32 leandiff; + s32 maxspeedtime240; + f32 speedabs[2]; + f32 speedrel[2]; +}; + +struct n64_hoverpropobj { + struct n64_defaultobj base; + struct n64_hov hov; +}; + +struct n64_fanobj { + struct n64_defaultobj base; + f32 yrot; + f32 yrotprev; + f32 ymaxspeed; + f32 yspeed; + f32 yaccel; + s8 on; + u8 _pad_[3]; +}; + +struct n64_hovercarobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 speed; + f32 speedaim; + f32 speedtime60; + f32 turnyspeed60; + f32 turnxspeed60; + f32 turnrot60; + f32 roty; + f32 rotx; + f32 rotz; + u32 ptr_path; + s32 nextstep; + s16 status; + s16 dead; + s16 deadtimer60; + s16 sparkstimer60; +}; + +struct n64_chopperobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + union { + struct { + f32 speed; + f32 speedaim; + f32 speedtime60; + }; + struct n64_coord fall; + }; + f32 turnyspeed60; + f32 turnxspeed60; + f32 turnrot60; + f32 roty; + f32 rotx; + f32 rotz; + u32 ptr_path; + s32 nextstep;// + s16 weaponsarmed; + s16 ontarget; + s16 target; + u8 attackmode; + u8 cw; + f32 vx; + f32 vy; + f32 vz; + f32 power; + f32 otx; + f32 oty; + f32 otz; + f32 bob; + f32 bobstrength; + s32 targetvisible; + s32 timer60; + s32 patroltimer60; + f32 gunturnyspeed60; + f32 gunturnxspeed60; + f32 gunroty; + f32 gunrotx; + f32 barrelrotspeed; + f32 barrelrot; + u32 ptr_fireslotthing; + s32 dead; +}; + +struct n64_escalatorobj { + struct n64_defaultobj base; + s32 frame; + struct n64_coord prevpos; +}; + +struct n64_textoverride { + u32 unk00; + s32 objoffset; + s32 weapon; + u32 obtaintext; + u32 ownertext; + u32 inventorytext; + u32 inventory2text; + u32 pickuptext; + u32 ptr_next; + u32 ptr_obj; +}; + +struct n64_criteria_roomentered { + u32 unk00; + u32 pad; + u32 status; + u32 ptr_next; +}; + +struct n64_criteria_throwinroom { + u32 unk00; + u32 unk04; + u32 pad; + u32 status; + u32 ptr_next; +}; + +struct n64_criteria_holograph { + u32 unk00; + u32 obj; + u32 status; + u32 ptr_next; +}; + +struct n64_ailist { + u32 ptr_list; + s32 id; +}; + +struct n64_path { + u32 ptr_pads; + u8 id; + u8 flags; + u16 len; +}; + +#endif \ No newline at end of file diff --git a/port/src/preprocess/util_gbi.c b/port/src/preprocess/util_gbi.c new file mode 100644 index 000000000..75b4a621a --- /dev/null +++ b/port/src/preprocess/util_gbi.c @@ -0,0 +1,209 @@ +#include +#include +#include +#include "common.h" +#include "gbi.h" + +#ifdef FORCE_BE32 +#define HOST_DWORDS_PER_CMD 1 +#elif UINTPTR_MAX == 0xFFFFFFFFFFFFFFFFu +#define HOST_DWORDS_PER_CMD 2 +#else +#define HOST_DWORDS_PER_CMD 1 +#endif + +struct vtx { + s16 x; + s16 y; + s16 z; + u8 flags; + u8 colour; + s16 s; + s16 t; +}; + +struct texaddr { + u32 src; + u32 dst; +}; + +u32 m_Segments[16]; +u32 m_SrcVtxOffset; +u32 m_DstVtxOffset; + +struct texaddr m_TexAddrs[64]; +int m_NumTexAddr; + +void gbiReset(void) +{ + for (int i = 0; i < ARRAYCOUNT(m_Segments); i++) { + m_Segments[i] = 0; + } + + m_SrcVtxOffset = 0; + m_DstVtxOffset = 0; + m_NumTexAddr = 0; +} + +void gbiSetSegment(int segment, u32 offset) +{ + m_Segments[segment] = offset & 0x00ffffff; +} + +void gbiSetVtx(u32 src_offset, u32 dst_offset) +{ + m_SrcVtxOffset = src_offset & 0x00ffffff; + m_DstVtxOffset = dst_offset & 0x00ffffff; +} + +void gbiAddTexAddr(u32 src_offset, u32 dst_offset) +{ + m_TexAddrs[m_NumTexAddr].src = src_offset & 0x00ffffff; + m_TexAddrs[m_NumTexAddr++].dst = dst_offset & 0x00ffffff; +} + +u32 gbiFindTexAddr(u32 src_offset) +{ + for (int i = 0; i < m_NumTexAddr; i++) { + if (m_TexAddrs[i].src == src_offset) + return m_TexAddrs[i].dst; + } + + return 0; +} + +void gbiConvertVtx(u8 *dst, u32 offset, int count) +{ + if (!offset) return; + struct vtx* vtxs = (struct vtx*)(dst + offset); + + for (int i = 0; i < count; i++) { + struct vtx* vtx = &vtxs[i]; + + vtx->x = srctodst16(vtx->x); + vtx->y = srctodst16(vtx->y); + vtx->z = srctodst16(vtx->z); + vtx->s = srctodst16(vtx->s); + vtx->t = srctodst16(vtx->t); + } +} + +#define CMD_IS_VTX(cmd) ((cmd & 0xff00000000000000) == 0x0400000000000000) +#define CMD_IS_DL(cmd) ((cmd & 0xff00000000000000) == 0x0600000000000000) +#define CMD_IS_COL(cmd) ((cmd & 0xff00000000000000) == 0x0700000000000000) +#define CMD_IS_ENDDL(cmd) ((cmd & 0xff00000000000000) == 0xb800000000000000) +#define CMD_IS_MOVEWORD(cmd) ((cmd & 0xff00000000000000) == 0xbc00000000000000) +#define CMD_IS_MOVEMEM(cmd) ((cmd & 0xff00000000000000) == 0x0300000000000000) +#define CMD_IS_MTX(cmd) ((cmd & 0xff00000000000000) == 0x0100000000000000) +#define CMD_IS_SETTIMG(cmd) ((cmd & 0xff00000000000000) == 0xfd00000000000000) +#define CMD_IS_SETZIMG(cmd) ((cmd & 0xff00000000000000) == 0xfe00000000000000) +#define CMD_IS_SETCIMG(cmd) ((cmd & 0xff00000000000000) == 0xff00000000000000) + +#define CMD_HAS_ADDR(cmd) CMD_IS_VTX(cmd) \ + || CMD_IS_COL(cmd) \ + || CMD_IS_MOVEWORD(cmd) \ + || CMD_IS_SETTIMG(cmd) + + +#define CMD_IS_SEGMENTED(cmd) ( CMD_IS_MOVEMEM(cmd) \ + || CMD_IS_MTX(cmd) \ + || CMD_IS_VTX(cmd) \ + || CMD_IS_COL(cmd) \ + || CMD_IS_DL(cmd) \ + || CMD_IS_SETTIMG(cmd) \ + || CMD_IS_SETCIMG(cmd) \ + || CMD_IS_SETZIMG(cmd)) + +/** + * Segment 5 is the start of the model file. The data in these files shifts + * depending on the pointer size, so this function adjusts the offset accordingly. + */ +static u64 gbiRewriteAddr(u64 cmd, u8 opcode) +{ + u8 segment = (cmd & 0x0f000000) >> 24; + u32 offset = cmd & 0x00ffffff; + + if (segment == 5) { + if (opcode == 0xfd) { + offset = gbiFindTexAddr(offset); + } + else { + if (offset < m_SrcVtxOffset) { + printf("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, m_SrcVtxOffset); + exit(EXIT_FAILURE); + } + + offset = offset - m_SrcVtxOffset + m_DstVtxOffset; + } + } + + return (cmd & 0xffffffffff000000) | offset; +} + +void gbiGdlRewriteAddrs(u8 *dst, u32 offset) +{ + if (!offset) return; + + u64 *cmds = (u64 *)(dst + (offset & 0x00ffffff)); + if (!cmds) return; + + u64 cmd; + + do { + cmd = *cmds; + Gfx* gfxcmd = cmds; + int idx = 0; + u8 opcode = (cmd >> 24) & 0xff; + +#if HOST_DWORDS_PER_CMD == 2 + idx = 1; + opcode = (cmd >> 24) & 0xff; +#endif + cmd = (u64)opcode << 56; + + if (CMD_HAS_ADDR(cmd)) { + cmds[idx] = gbiRewriteAddr(cmds[idx], opcode); + } + + if (CMD_IS_SEGMENTED(cmd)) { + gfxcmd->words.w1 |= 1; + } + + cmds += HOST_DWORDS_PER_CMD; + } while (!CMD_IS_ENDDL(cmd)); +} + +u32 gbiConvertGdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds) +{ + dstpos = ALIGN8(dstpos); + + u64 *n64_cmd = (u64*)&src[srcpos]; + u64 *host_cmd = (u64*)&dst[dstpos]; + u64 cmd; + + do { + cmd = srctoh64(*n64_cmd); + +#if HOST_DWORDS_PER_CMD == 2 + host_cmd[0] = htodst64((cmd & 0xffffffff00000000) >> 32); + host_cmd[1] = htodst64(cmd & 0xffffffff); + + if (segment_cmds && CMD_IS_SEGMENTED(cmd)) { + host_cmd[1] |= 1; + } +#else + host_cmd[0] = (cmd >> 32) | ((cmd & 0xffffffff) << 32); + + if (segment_cmds && CMD_IS_SEGMENTED(cmd)) { + Gfx* gfxcmd = (Gfx*)host_cmd; + gfxcmd->words.w1 |= 1; + } +#endif + + dstpos += sizeof(*host_cmd) * HOST_DWORDS_PER_CMD; + host_cmd += HOST_DWORDS_PER_CMD; + n64_cmd++; + } while (!CMD_IS_ENDDL(cmd)); + + return dstpos; +} From d6d4bc2c147922fc8ddd0c24b1e18fe0814dc4a7 Mon Sep 17 00:00:00 2001 From: Raf Date: Thu, 8 Aug 2024 23:55:26 +0800 Subject: [PATCH 35/81] Update c-cpp.yml --- .github/workflows/c-cpp.yml | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 3515c9d3b..2ef68d970 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -2,9 +2,9 @@ name: C/C++ CI on: push: - branches: [ "port" ] + branches: [ "port-x64" ] pull_request: - branches: [ "port" ] + branches: [ "port-x64" ] workflow_dispatch: jobs: @@ -17,7 +17,7 @@ jobs: - name: Install MSYS2 uses: msys2/setup-msys2@v2 with: - msystem: MINGW32 + msystem: MINGW64 update: true install: >- git @@ -39,12 +39,12 @@ jobs: cp build/ntsc-final-port/pd.exe bin/ cp build/pal-final-port/pd.pal.exe bin/ cp build/jpn-final-port/pd.jpn.exe bin/ - cp /mingw32/bin/{SDL2.dll,zlib1.dll,libgcc_s_dw2-1.dll,libwinpthread-1.dll} bin/ + cp /mingw64/bin/{SDL2.dll,zlib1.dll,libgcc_s_dw2-1.dll,libwinpthread-1.dll} bin/ touch bin/data/put_your_rom_here.txt - name: Upload artifact uses: actions/upload-artifact@v4 with: - name: pd-i686-windows + name: pd-i686-windows-x64 path: bin/ retention-days: 0 @@ -53,7 +53,7 @@ jobs: steps: - name: Install dependencies run: | - sudo dpkg --add-architecture i386 + sudo dpkg --add-architecture amd64 sudo apt-get update sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-dev:i386 zlib1g-dev:i386 - name: Checkout repository @@ -74,13 +74,13 @@ jobs: - name: Upload artifact uses: actions/upload-artifact@v4 with: - name: pd-i686-linux + name: pd-i686-linux-x64 path: bin/ retention-days: 0 publish-latest-build: runs-on: ubuntu-latest - if: github.ref == 'refs/heads/port' + if: github.ref == 'refs/heads/port-x64' needs: [build-i686-windows, build-i686-linux] permissions: contents: write @@ -95,9 +95,9 @@ jobs: run: | mkdir ci-release pushd ci-artifacts - tar czf ../ci-release/pd-i686-linux.tar.gz pd-i686-linux - zip -r ../ci-release/pd-i686-windows.zip pd-i686-windows + tar czf ../ci-release/pd-i686-linux-x64.tar.gz pd-i686-linux-x64 + zip -r ../ci-release/pd-i686-windows-x64.zip pd-i686-windows-x64 popd - git tag --force ci-dev-build port - git push --force origin ci-dev-build - gh release upload --clobber ci-dev-build ci-release/* + git tag --force ci-dev-build-x64 port + git push --force origin ci-dev-build-x64 + gh release upload --clobber ci-dev-build-x64 ci-release/* From 18fe7fd797b845e153b79a9007ef83bfb8569e6c Mon Sep 17 00:00:00 2001 From: Raf Date: Fri, 9 Aug 2024 00:23:03 +0800 Subject: [PATCH 36/81] Update c-cpp.yml --- .github/workflows/c-cpp.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 2ef68d970..64f048bb3 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -23,6 +23,7 @@ jobs: git make mingw-w64-i686-toolchain + mingw-w64-i686-python mingw-w64-i686-SDL2 mingw-w64-i686-zlib - name: Checkout repository From c36b6b286df9aa2d2f0ae8570228f0e59bbe8cb6 Mon Sep 17 00:00:00 2001 From: Raf Date: Fri, 9 Aug 2024 00:36:42 +0800 Subject: [PATCH 37/81] Update c-cpp.yml --- .github/workflows/c-cpp.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 64f048bb3..6b2b689b8 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -22,10 +22,10 @@ jobs: install: >- git make - mingw-w64-i686-toolchain - mingw-w64-i686-python - mingw-w64-i686-SDL2 - mingw-w64-i686-zlib + mingw-w64-x86_64-toolchain + mingw-w64-x86_64-python + mingw-w64-x86_64-SDL2 + mingw-w64-x86_64-zlib - name: Checkout repository uses: actions/checkout@v4 - name: Build pd.exe @@ -56,7 +56,7 @@ jobs: run: | sudo dpkg --add-architecture amd64 sudo apt-get update - sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-dev:i386 zlib1g-dev:i386 + sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-dev zlib1g-dev - name: Checkout repository uses: actions/checkout@v4 - name: Build pd.exe From a11abc051112c7d1e2c39404fce83a3d24f95ebf Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 00:47:55 +0800 Subject: [PATCH 38/81] portx64: forgot to commit the removal of pdextract files --- port/pdextract/common.c | 33 - port/pdextract/common.h | 93 --- port/pdextract/ext_audio.c | 429 ----------- port/pdextract/ext_file_bg.c | 597 --------------- port/pdextract/ext_file_lang.c | 95 --- port/pdextract/ext_file_model.c | 1028 -------------------------- port/pdextract/ext_file_pads.c | 330 --------- port/pdextract/ext_file_tiles.c | 107 --- port/pdextract/ext_fonts.c | 122 ---- port/pdextract/ext_setups.c | 1202 ------------------------------- port/pdextract/setups_decl.h | 642 ----------------- port/pdextract/util_gbi.c | 209 ------ 12 files changed, 4887 deletions(-) delete mode 100644 port/pdextract/common.c delete mode 100644 port/pdextract/common.h delete mode 100644 port/pdextract/ext_audio.c delete mode 100644 port/pdextract/ext_file_bg.c delete mode 100644 port/pdextract/ext_file_lang.c delete mode 100644 port/pdextract/ext_file_model.c delete mode 100644 port/pdextract/ext_file_pads.c delete mode 100644 port/pdextract/ext_file_tiles.c delete mode 100644 port/pdextract/ext_fonts.c delete mode 100644 port/pdextract/ext_setups.c delete mode 100644 port/pdextract/setups_decl.h delete mode 100644 port/pdextract/util_gbi.c diff --git a/port/pdextract/common.c b/port/pdextract/common.c deleted file mode 100644 index 3a9f5190f..000000000 --- a/port/pdextract/common.c +++ /dev/null @@ -1,33 +0,0 @@ -#include "common.h" -#include "system.h" - -struct ptrmarker m_PtrMarkers[1024*8]; -int m_NumPtrMarkers; - -void add_marker(u32 ptr_src, uintptr_t ptr_host) -{ - if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { - sysLogPrintf(LOG_ERROR, "Marker limit exceeded"); - exit(EXIT_FAILURE); - } - - m_PtrMarkers[m_NumPtrMarkers].ptr_src = ptr_src; - m_PtrMarkers[m_NumPtrMarkers].ptr_host = ptr_host; - m_NumPtrMarkers++; -} - -struct ptrmarker* find_ptr_marker(uintptr_t ptr_src) -{ - for (int i = 0; i < m_NumPtrMarkers; i++) { - if (m_PtrMarkers[i].ptr_src == ptr_src) { - return &m_PtrMarkers[i]; - } - } - - return NULL; -} - -void reset_markers() -{ - m_NumPtrMarkers = 0; -} diff --git a/port/pdextract/common.h b/port/pdextract/common.h deleted file mode 100644 index 4d0141f32..000000000 --- a/port/pdextract/common.h +++ /dev/null @@ -1,93 +0,0 @@ -#ifndef _PDE_COMMON_H -#define _PDE_COMMON_H - -#include -#include -#include - -#include -// this BS comes from windows.h -#undef near -#undef far - -#include - -#include - -#include "constants.h" - - -#if __BIG_ENDIAN__ - #define htonll(x) (x) - #define ntohll(x) (x) -#else - #define htonll(x) ((((uint64_t)htonl(x&0xFFFFFFFF)) << 32) + htonl(x >> 32)) - #define ntohll(x) ((((uint64_t)ntohl(x&0xFFFFFFFF)) << 32) + ntohl(x >> 32)) -#endif - -#define htobe16(x) htons(x) -#define htole16(x) (x) -#define be16toh(x) ntohs(x) -#define le16toh(x) (x) - -#define htobe32(x) htonl(x) -#define htole32(x) (x) -#define be32toh(x) ntohl(x) -#define le32toh(x) (x) - -#define htobe64(x) htonll(x) -#define htole64(x) (x) -#define be64toh(x) ntohll(x) -#define le64toh(x) (x) - - -#define srctoh16(value) ntohs(value) -#define srctoh32(value) ntohl(value) -#define srctoh64(value) ntohll(value) - -#ifdef FORCE_BE32 -#define htodst16(value) htons(value) -#define htodst32(value) htonl(value) -#define htodst64(value) htonll(value) -#define dsttoh16(value) ntohs(value) -#define dsttoh32(value) ntohl(value) -#define dsttoh64(value) ntohll(value) -#else -#define htodst16(value) (value) -#define htodst32(value) (value) -#define htodst64(value) (value) -#define dsttoh16(value) (value) -#define dsttoh32(value) (value) -#define dsttoh64(value) (value) -#endif - -#define srctodst16(value) htodst16(srctoh16(value)) -#define srctodst32(value) htodst32(srctoh32(value)) -#define srctodst64(value) htodst64(srctoh64(value)) - -#ifdef FORCE_BE32 -#define uintptr_t u32 -#endif - -#define ALIGN(val, size) ((val + (size - 1)) & ~(size - 1)) - -// gbi related functions -void gbi_reset(void); -void gbi_set_segment(int segment, u32 offset); -void gbi_set_vtx(u32 src_offset, u32 dst_offset); -u32 gbi_convert_gdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds); -void gbi_convert_vtx(u8* dst, u32 dstpos, int count); -void gbi_gdl_rewrite_addrs(u8* dst, u32 offset); -void gbi_add_tex_addr(u32 src_offset, u32 dst_offset); - -// ptr marker functions -struct ptrmarker { - u32 ptr_src; - uintptr_t ptr_host; -}; - -void add_marker(u32 ptr_src, uintptr_t ptr_host); -struct ptrmarker* find_ptr_marker(uintptr_t ptr_src); -void reset_markers(); - -#endif diff --git a/port/pdextract/ext_audio.c b/port/pdextract/ext_audio.c deleted file mode 100644 index f42de4725..000000000 --- a/port/pdextract/ext_audio.c +++ /dev/null @@ -1,429 +0,0 @@ -#include -#include -#include - -#include "common.h" -#include "system.h" - -enum { - AL_ADPCM_WAVE = 0, - AL_RAW16_WAVE -}; - -struct generic_adpcm_book { - s32 order; - s32 npredictors; - s16 book[128]; -}; - -struct generic_adpcm_loop { - u32 start; - u32 end; - u32 count; - s16 state[16]; -}; - -struct generic_raw_loop { - u32 start; - u32 end; - u32 count; -}; - -struct generic_envelope { - s32 attackTime; - s32 decayTime; - s32 releaseTime; - u8 attackVolume; - u8 decayVolume; -}; - -struct generic_keymap { - u8 velocityMin; - u8 velocityMax; - u8 keyMin; - u8 keyMax; - u8 keyBase; - s8 detune; -}; - -struct n64_adpcm_waveinfo { - u32 loop; // ptr to struct generic_adpcm_loop - u32 book; // ptr to struct generic_adpcm_book -}; - -struct host_adpcm_waveinfo { - uintptr_t loop; // ptr to struct generic_adpcm_loop - uintptr_t book; // ptr to struct generic_adpcm_book -}; - -struct n64_raw_waveinfo { - u32 loop; // ptr to struct generic_raw_loop -}; - -struct host_raw_waveinfo { - uintptr_t loop; // ptr to struct generic_raw_loop -}; - -struct n64_wavetable { - u32 base; - s32 len; - u8 type; - u8 flags; - union { - struct n64_adpcm_waveinfo adpcmWave; - struct n64_raw_waveinfo rawWave; - } waveInfo; -}; - -struct host_wavetable { - uintptr_t base; - s32 len; - u8 type; - u8 flags; - union { - struct host_adpcm_waveinfo adpcmWave; - struct host_raw_waveinfo rawWave; - } waveInfo; -}; - -struct n64_sound { - u32 envelope; // ptr to struct generic_envelope - u32 keyMap; // ptr to struct generic_keymap - u32 wavetable; // ptr to struct n64_wavetable - u8 samplePan; - u8 sampleVolume; - u8 flags; -}; - -struct host_sound { - uintptr_t envelope; // ptr to struct generic_envelope - uintptr_t keyMap; // ptr to struct generic_keymap - uintptr_t wavetable; // ptr to struct host_wavetable - u8 samplePan; - u8 sampleVolume; - u8 flags; -}; - -struct n64_instrument { - u8 volume; - u8 pan; - u8 priority; - u8 flags; - u8 tremType; - u8 tremRate; - u8 tremDepth; - u8 tremDelay; - u8 vibType; - u8 vibRate; - u8 vibDepth; - u8 vibDelay; - s16 bendRange; - s16 soundCount; - u32 soundArray[1]; // ptr to struct n64_sound -}; - -struct host_instrument { - u8 volume; - u8 pan; - u8 priority; - u8 flags; - u8 tremType; - u8 tremRate; - u8 tremDepth; - u8 tremDelay; - u8 vibType; - u8 vibRate; - u8 vibDepth; - u8 vibDelay; - s16 bendRange; - s16 soundCount; - uintptr_t soundArray[1]; // ptr to struct host_sound -}; - -struct n64_bank { - s16 instCount; - u8 flags; - u8 pad; - s32 sampleRate; - u32 percussion; // ptr to struct n64_instrument - u32 instArray[1]; // ptr to struct n64_instrument -}; - -struct host_bank { - s16 instCount; - u8 flags; - u8 pad; - s32 sampleRate; - uintptr_t percussion; // ptr to struct host_instrument - uintptr_t instArray[1]; // ptr to struct host_instrument -}; - -struct n64_bankfile { - s16 revision; - s16 bankCount; - u32 bankArray[1]; // ptr to struct n64_bank -}; - -struct host_bankfile { - s16 revision; - s16 bankCount; - uintptr_t bankArray[1]; // ptr to struct host_bank -}; - -// only proceeds to convert the next item if it's not already converted -#define AL_NEXT_ITEM(field, func) { \ - struct ptrmarker *marker = find_ptr_marker(srcpos); \ - if (marker == NULL) { \ - field = htodst32(dstpos); \ - add_marker(srcpos, field); \ - dstpos = func(dst, dstpos, src, srcpos); \ - } else { \ - field = marker->ptr_host; } \ -} - -static int convert_audio_envelope(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct generic_envelope *n64_envelope = (struct generic_envelope *) &src[srcpos]; - struct generic_envelope *host_envelope = (struct generic_envelope *) &dst[dstpos]; - - dstpos += sizeof(struct generic_envelope); - - host_envelope->attackTime = srctodst32(n64_envelope->attackTime); - host_envelope->decayTime = srctodst32(n64_envelope->decayTime); - host_envelope->releaseTime = srctodst32(n64_envelope->releaseTime); - host_envelope->attackVolume = n64_envelope->attackVolume; - host_envelope->decayVolume = n64_envelope->decayVolume; - - return dstpos; -} - -static int convert_audio_keymap(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct generic_keymap *n64_keymap = (struct generic_keymap *) &src[srcpos]; - struct generic_keymap *host_keymap = (struct generic_keymap *) &dst[dstpos]; - - dstpos += sizeof(struct generic_keymap); - - host_keymap->velocityMin = n64_keymap->velocityMin; - host_keymap->velocityMax = n64_keymap->velocityMax; - host_keymap->keyMin = n64_keymap->keyMin; - host_keymap->keyMax = n64_keymap->keyMax; - host_keymap->keyBase = n64_keymap->keyBase; - host_keymap->detune = n64_keymap->detune; - - return dstpos; -} - -static int convert_audio_adpcm_loop(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct generic_adpcm_loop *n64_loop = (struct generic_adpcm_loop *) &src[srcpos]; - struct generic_adpcm_loop *host_loop = (struct generic_adpcm_loop *) &dst[dstpos]; - - dstpos += sizeof(struct generic_adpcm_loop); - - host_loop->start = srctodst32(n64_loop->start); - host_loop->end = srctodst32(n64_loop->end); - host_loop->count = srctodst32(n64_loop->count); - - for (int i = 0; i < ARRAYCOUNT(host_loop->state); i++) { - host_loop->state[i] = srctodst16(n64_loop->state[i]); - } - - return dstpos; -} - -static int convert_audio_adpcm_book(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct generic_adpcm_book *n64_book = (struct generic_adpcm_book *) &src[srcpos]; - struct generic_adpcm_book *host_book = (struct generic_adpcm_book *) &dst[dstpos]; - - dstpos += sizeof(struct generic_adpcm_book); - - host_book->order = srctodst32(n64_book->order); - host_book->npredictors = srctodst32(n64_book->npredictors); - - for (int i = 0; i < ARRAYCOUNT(host_book->book); i++) { - host_book->book[i] = srctodst16(n64_book->book[i]); - } - - return dstpos; -} - -static int convert_audio_raw_loop(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct generic_raw_loop *n64_loop = (struct generic_raw_loop *) &src[srcpos]; - struct generic_raw_loop *host_loop = (struct generic_raw_loop *) &dst[dstpos]; - - dstpos += sizeof(struct generic_raw_loop); - - host_loop->start = srctodst32(n64_loop->start); - host_loop->end = srctodst32(n64_loop->end); - host_loop->count = srctodst32(n64_loop->count); - - return dstpos; -} - -static int convert_audio_wavetable(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct n64_wavetable *n64_wavetable = (struct n64_wavetable *) &src[srcpos]; - struct host_wavetable *host_wavetable = (struct host_wavetable *) &dst[dstpos]; - - dstpos += sizeof(struct host_wavetable); - - host_wavetable->base = srctodst32(n64_wavetable->base); - host_wavetable->len = srctodst32(n64_wavetable->len); - host_wavetable->type = n64_wavetable->type; - host_wavetable->flags = n64_wavetable->flags; - - if (host_wavetable->type == AL_ADPCM_WAVE) { - if (n64_wavetable->waveInfo.adpcmWave.loop) { - srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.loop); - AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.loop, convert_audio_adpcm_loop); - } else { - host_wavetable->waveInfo.adpcmWave.loop = 0; - } - - if (n64_wavetable->waveInfo.adpcmWave.book) { - srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.book); - AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.book, convert_audio_adpcm_book); - } else { - host_wavetable->waveInfo.adpcmWave.book = 0; - } - } else if (host_wavetable->type == AL_RAW16_WAVE) { - if (n64_wavetable->waveInfo.rawWave.loop) { - srcpos = srctoh32(n64_wavetable->waveInfo.rawWave.loop); - AL_NEXT_ITEM(host_wavetable->waveInfo.rawWave.loop, convert_audio_raw_loop); - } else { - host_wavetable->waveInfo.rawWave.loop = 0; - } - } - - return dstpos; -} - -static int convert_audio_sound(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct n64_sound *n64_sound = (struct n64_sound *) &src[srcpos]; - struct host_sound *host_sound = (struct host_sound *) &dst[dstpos]; - - dstpos += sizeof(struct host_sound); - - if (n64_sound->envelope) { - srcpos = srctoh32(n64_sound->envelope); - AL_NEXT_ITEM(host_sound->envelope, convert_audio_envelope); - } else { - host_sound->envelope = 0; - } - - if (n64_sound->keyMap) { - srcpos = srctoh32(n64_sound->keyMap); - AL_NEXT_ITEM(host_sound->keyMap, convert_audio_keymap); - } else { - host_sound->keyMap = 0; - } - - if (n64_sound->wavetable) { - srcpos = srctoh32(n64_sound->wavetable); - AL_NEXT_ITEM(host_sound->wavetable, convert_audio_wavetable); - } else { - host_sound->wavetable = 0; - } - - host_sound->samplePan = n64_sound->samplePan; - host_sound->sampleVolume = n64_sound->sampleVolume; - host_sound->flags = n64_sound->flags; - - return dstpos; -} - -static int convert_audio_instrument(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct n64_instrument *n64_instrument = (struct n64_instrument *) &src[srcpos]; - struct host_instrument *host_instrument = (struct host_instrument *) &dst[dstpos]; - int soundCount = srctoh16(n64_instrument->soundCount); - - host_instrument->volume = n64_instrument->volume; - host_instrument->pan = n64_instrument->pan; - host_instrument->priority = n64_instrument->priority; - host_instrument->flags = n64_instrument->flags; - host_instrument->tremType = n64_instrument->tremType; - host_instrument->tremRate = n64_instrument->tremRate; - host_instrument->tremDepth = n64_instrument->tremDepth; - host_instrument->tremDelay = n64_instrument->tremDelay; - host_instrument->vibType = n64_instrument->vibType; - host_instrument->vibRate = n64_instrument->vibRate; - host_instrument->vibDepth = n64_instrument->vibDepth; - host_instrument->vibDelay = n64_instrument->vibDelay; - host_instrument->bendRange = srctodst16(n64_instrument->bendRange); - host_instrument->soundCount = htodst16(soundCount); - - dstpos = dstpos + sizeof(struct host_instrument) + sizeof(uintptr_t) * (soundCount - 1); - - for (int i = 0; i < soundCount; i++) { - srcpos = srctoh32(n64_instrument->soundArray[i]); - AL_NEXT_ITEM(host_instrument->soundArray[i], convert_audio_sound); - } - - return dstpos; -} - -static int convert_audio_bank(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct n64_bank *n64_bank = (struct n64_bank *) &src[srcpos]; - struct host_bank *host_bank = (struct host_bank *) &dst[dstpos]; - int instCount = srctoh16(n64_bank->instCount); - - host_bank->instCount = htodst16(instCount); - host_bank->flags = n64_bank->flags; - host_bank->pad = n64_bank->pad; - host_bank->sampleRate = srctodst32(n64_bank->sampleRate); - - dstpos = dstpos + sizeof(struct host_bank) + sizeof(uintptr_t) * (instCount - 1); - - if (n64_bank->percussion) { - srcpos = srctoh32(n64_bank->percussion); - AL_NEXT_ITEM(host_bank->percussion, convert_audio_instrument); - } else { - host_bank->percussion = 0; - } - - for (int i = 0; i < instCount; i++) { - srcpos = srctoh32(n64_bank->instArray[i]); - AL_NEXT_ITEM(host_bank->instArray[i], convert_audio_instrument); - } - - return dstpos; -} - -static int convert_audio_bankfile(u8 *dst, u8 *src) -{ - struct n64_bankfile *n64_bankfile = (struct n64_bankfile *)src; - struct host_bankfile *host_bankfile = (struct host_bankfile *)dst; - int bankCount = srctoh16(n64_bankfile->bankCount); - - host_bankfile->revision = srctodst16(n64_bankfile->revision); - host_bankfile->bankCount = htodst16(bankCount); - - - u32 dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); - - for (int i = 0; i < bankCount; i++) { - host_bankfile->bankArray[i] = htodst32(dstpos); - u32 srcpos = srctoh32(n64_bankfile->bankArray[i]); - dstpos = convert_audio_bank(dst, dstpos, src, srcpos); - } - - return dstpos; -} - -u8 *preprocessALBankFile(u8 *src, u32 size, u32 *outSize) -{ - reset_markers(); - u32 dstlen = size * 3; - u8 *dst = sysMemZeroAlloc(dstlen); - - *outSize = convert_audio_bankfile(dst, src); - *outSize = ALIGN16(*outSize); - - return dst; -} diff --git a/port/pdextract/ext_file_bg.c b/port/pdextract/ext_file_bg.c deleted file mode 100644 index dc3d57243..000000000 --- a/port/pdextract/ext_file_bg.c +++ /dev/null @@ -1,597 +0,0 @@ -#include -#include -#include -#include -#include "common.h" -#include "system.h" -#include "platform.h" - -int m_SizeGDLs; - -/** - * 4 bytes decompressed size of primary data - * 4 bytes compressed size of section 1 in its entirety - * 4 bytes compressed size of primary data - * Section 1: - * Primary: (zipped) - * 4 bytes null - * 4 bytes pointer to room table - * 4 bytes pointer to portal table - * 4 bytes pointer to bgcmds - * 4 bytes pointer to lights table - * 4 bytes null - * (room table) - * (portal table) - * (bgcmds) - * (lights table) - * room 1 (zipped) - * room 2 (zipped) - * ... - * Section 2: - * 2 bytes decompressed size of section (mask with 0x7fff) - * 2 bytes compressed size of section - * Texture ID list (zipped) - * Section 3: - * 2 bytes decompressed size of section (mask with 0x7fff) - * 2 bytes compressed size of section - * Zipped: - * (room bbox table) - * (list of roomgfxdata sizes) - * (list of light counts per room) - */ - -struct fileheader { - u32 primary_infsize; - u32 section1_cmpsize; - u32 primary_cmpsize; -}; - -struct sectionheader { - u16 infsize; - u16 cmpsize; -}; - -struct n64_primaryheader { - u32 unused1; - u32 ptr_rooms; - u32 ptr_portals; - u32 ptr_bgcmds; - u32 ptr_lights; - u32 unused2; -}; - -struct host_primaryheader { - uintptr_t unused1; - uintptr_t ptr_rooms; - uintptr_t ptr_portals; - uintptr_t ptr_bgcmds; - uintptr_t ptr_lights; - uintptr_t unused2; -}; - -struct n64_room { - u32 ptr_gfxdata; - u32 pos[3]; - u8 br_light_min; - u8 br_light_max; -}; - -struct host_room { - uintptr_t ptr_gfxdata; - u32 pos[3]; - u8 br_light_min; - u8 br_light_max; -}; - -struct portal { - u16 verticesoffset; - s16 roomnum1; - s16 roomnum2; - u8 flags; -}; - -struct portalvertices { - u8 count; - u32 vertices[1][3]; -}; - -struct bgcmd { - u8 type; - u8 len; - s32 param; -}; - -struct light { - u16 roomnum; - u16 colour; - u8 brightness; - u8 sparkable : 1; - u8 healthy : 1; - u8 on : 1; - u8 sparking : 1; - u8 vulnerable : 1; - u8 brightnessmult; - s8 dirx; - s8 diry; - s8 dirz; - s16 bbox[4][3]; -}; - -struct n64_roomblock { - u8 type; - u32 ptr_next; - u32 ptr_gdl; - u32 ptr_vertices; - u32 ptr_colours; -}; - -struct host_roomblock { - u8 type; - uintptr_t ptr_next; - uintptr_t ptr_gdl; - uintptr_t ptr_vertices; - uintptr_t ptr_colours; -}; - -struct n64_roomgfxdata { - u32 ptr_vertices; - u32 ptr_colours; - u32 ptr_opablocks; - u32 ptr_xlublocks; - s16 lightsindex; - s16 numlights; - s16 numvertices; - s16 numcolours; - // roomblocks[] -}; - -struct host_roomgfxdata { - uintptr_t ptr_vertices; - uintptr_t ptr_colours; - uintptr_t ptr_opablocks; - uintptr_t ptr_xlublocks; - s16 lightsindex; - s16 numlights; - s16 numvertices; - s16 numcolours; - // roomblocks[] -}; - -struct vtx { - s16 coord[3]; - u8 flag; - u8 color; - u16 s; - u16 t; -}; - -int m_NumRooms; - -u32 m_AllocSizes[512]; - -static void convert_primary_rooms(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) -{ - struct n64_room *n64_rooms = (struct n64_room *) &src[*srcpos]; - struct host_room *host_rooms = (struct host_room *) &dst[*dstpos]; - - m_NumRooms = 0; - - for (int i = 1; n64_rooms[i].ptr_gfxdata != 0; i++) { - m_NumRooms++; - } - - for (int i = 0; i < m_NumRooms + 1; i++) { - host_rooms[i].ptr_gfxdata = srctodst32(n64_rooms[i].ptr_gfxdata); - host_rooms[i].pos[0] = srctodst32(n64_rooms[i].pos[0]); - host_rooms[i].pos[1] = srctodst32(n64_rooms[i].pos[1]); - host_rooms[i].pos[2] = srctodst32(n64_rooms[i].pos[2]); - host_rooms[i].br_light_min = n64_rooms[i].br_light_min; - host_rooms[i].br_light_max = n64_rooms[i].br_light_max; - } - - *srcpos += sizeof(*n64_rooms) * (m_NumRooms + 2); - *dstpos += sizeof(*host_rooms) * (m_NumRooms +2); -} - -static void convert_primary_portals(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 *src_portalvtxs, u32 *dst_portalvtxs) -{ - struct portal *n64_portals = (struct portal *) &src[*srcpos]; - struct portal *host_portals = (struct portal *) &dst[*dstpos]; - - // Count portals - int numportals = 0; - - for (int i = 0; n64_portals[i].verticesoffset != 0; i++) { - numportals++; - } - - // Convert portals - for (int i = 0; i < numportals; i++) { - host_portals[i].verticesoffset = srctodst16(n64_portals[i].verticesoffset); - host_portals[i].roomnum1 = srctodst16(n64_portals[i].roomnum1); - host_portals[i].roomnum2 = srctodst16(n64_portals[i].roomnum2); - host_portals[i].flags = n64_portals[i].flags; - } - - *srcpos += sizeof(*n64_portals) * (numportals + 1); - *dstpos += sizeof(*host_portals) * (numportals + 1); - - *src_portalvtxs = *srcpos; - *dst_portalvtxs = *dstpos; - - while (1) { - struct portalvertices *n64_pvertices = (struct portalvertices*)&src[*srcpos]; - struct portalvertices *host_pvertices = (struct portalvertices*)&dst[*dstpos]; - - host_pvertices->count = n64_pvertices->count; - - for (int j = 0; j < host_pvertices->count; j++) { - host_pvertices->vertices[j][0] = srctodst32(n64_pvertices->vertices[j][0]); - host_pvertices->vertices[j][1] = srctodst32(n64_pvertices->vertices[j][1]); - host_pvertices->vertices[j][2] = srctodst32(n64_pvertices->vertices[j][2]); - } - - *srcpos += 4 + host_pvertices->count * 12; - *dstpos += 4 + host_pvertices->count * 12; - - if (host_pvertices->count == 0) break; - } -} - -static void convert_primary_bgcmds(u8 *dst, u32 *dstpos, u8 *src, u32 dst_portalvtxs, u32 src_portalvtxs) -{ - struct bgcmd *n64_cmds = (struct bgcmd *) src; - struct bgcmd *host_cmds = (struct bgcmd *) &dst[*dstpos]; - int num_cmds = 0; - - for (int i = 0; n64_cmds[i].type != 0; i++) { - num_cmds++; - } - - num_cmds++; - - for (int i = 0; i < num_cmds; i++) { - host_cmds[i].type = n64_cmds[i].type; - host_cmds[i].len = n64_cmds[i].len; - host_cmds[i].param = srctodst32(n64_cmds[i].param); - - if (host_cmds[i].type == 0x64) { - u32 offset = host_cmds[i].param - src_portalvtxs; - host_cmds[i].param = dst_portalvtxs + offset; - } - } - - *dstpos += sizeof(*host_cmds) * num_cmds; -} - -static void convert_primary_lights(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 end) -{ - struct light *n64_lights = (struct light *) &src[*srcpos]; - struct light *host_lights = (struct light *) &dst[*dstpos]; - int num_lights = (end - *srcpos) / sizeof(struct light); - - for (int i = 0; i < num_lights; i++) { - host_lights[i].roomnum = srctodst16(n64_lights[i].roomnum); - host_lights[i].colour = srctodst16(n64_lights[i].colour); - host_lights[i].brightness = n64_lights[i].brightness; - host_lights[i].sparkable = n64_lights[i].sparkable; - host_lights[i].healthy = n64_lights[i].healthy; - host_lights[i].on = n64_lights[i].on; - host_lights[i].sparking = n64_lights[i].sparking; - host_lights[i].vulnerable = n64_lights[i].vulnerable; - host_lights[i].brightnessmult = n64_lights[i].brightnessmult; - host_lights[i].dirx = n64_lights[i].dirx; - host_lights[i].diry = n64_lights[i].diry; - host_lights[i].dirz = n64_lights[i].dirz; - - for (int j = 0; j < 4; j++) { - host_lights[i].bbox[j][0] = srctodst16(n64_lights[i].bbox[j][0]); - host_lights[i].bbox[j][1] = srctodst16(n64_lights[i].bbox[j][1]); - host_lights[i].bbox[j][2] = srctodst16(n64_lights[i].bbox[j][2]); - } - } - - *srcpos += sizeof(*n64_lights) * num_lights; - *dstpos += sizeof(*host_lights) * num_lights; -} - -#define BLOCK_LEAF 0 -#define BLOCK_PARENT 1 - -void relink_ptr(uintptr_t** ptr) -{ - if (!*ptr) return; - - struct ptrmarker* marker = find_ptr_marker(*ptr); - if (!marker) { - fprintf(stderr, "[BG] WARNING: Unable to relink pointer: %p\n", ptr); - exit(EXIT_FAILURE); - } - - *ptr = marker->ptr_host; -} - -static u32 convert_section1_roomgfxdata(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) -{ - reset_markers(); - - u32 dst_roomoffset = src_ofs; - - uintptr_t gdls_addr[64]; - int numgdls = 0; - - struct n64_roomgfxdata *src_header = (struct n64_roomgfxdata*)src; - struct host_roomgfxdata *dst_header = (struct host_roomgfxdata*)dst; - - dst_header->ptr_vertices = srctoh32(src_header->ptr_vertices); - dst_header->ptr_colours = srctoh32(src_header->ptr_colours); - dst_header->ptr_opablocks = srctoh32(src_header->ptr_opablocks); - dst_header->ptr_xlublocks = srctoh32(src_header->ptr_xlublocks); - dst_header->lightsindex = srctoh16(src_header->lightsindex); - dst_header->numlights = srctoh16(src_header->numlights); - dst_header->numvertices = srctoh16(src_header->numvertices); - dst_header->numcolours = srctoh16(src_header->numcolours); - - intptr_t endpos = dst_header->ptr_vertices - src_ofs; - uintptr_t curpos_src = sizeof(struct n64_roomgfxdata); - uintptr_t curpos_dst = sizeof(struct host_roomgfxdata); - - // roomblocks - int ncoords = 0; - - // save the ptr to roomblocks here to iterate later to fix the pointers - struct host_roomblock *ptr_dst_roomblocks = (struct host_roomblock*)&dst[curpos_dst]; - - int numblocks = 0; - while ((intptr_t)(curpos_src + sizeof(struct n64_roomblock)) <= endpos) { - struct n64_roomblock *src_roomblock = (struct n64_roomblock*)&src[curpos_src]; - struct host_roomblock *dest_roomblock = (struct host_roomblock*)&dst[curpos_dst]; - - dest_roomblock->type = src_roomblock->type; - dest_roomblock->ptr_next = srctoh32(src_roomblock->ptr_next); - dest_roomblock->ptr_gdl = srctoh32(src_roomblock->ptr_gdl); - dest_roomblock->ptr_vertices = srctoh32(src_roomblock->ptr_vertices); - dest_roomblock->ptr_colours = srctoh32(src_roomblock->ptr_colours); - - add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - - if (src_roomblock->type == BLOCK_PARENT) { - ncoords++; - uintptr_t vtx_ptr = dest_roomblock->ptr_vertices - src_ofs; - if (vtx_ptr < endpos) endpos = vtx_ptr; - } - else if (src_roomblock->ptr_gdl) { - gdls_addr[numgdls++] = srctoh32(src_roomblock->ptr_gdl) - src_ofs; - } - - curpos_src += sizeof(struct n64_roomblock); - curpos_dst += sizeof(struct host_roomblock); - numblocks++; - } - - // block coords - for (size_t i = 0; i < ncoords; i++) { - u32 *src_coord = (u32*)(src + curpos_src); - u32 *dst_coord = (u32*)(dst + curpos_dst); - - dst_coord[0] = srctoh32(src_coord[0]); - dst_coord[1] = srctoh32(src_coord[1]); - dst_coord[2] = srctoh32(src_coord[2]); - - dst_coord[3] = srctoh32(src_coord[3]); - dst_coord[4] = srctoh32(src_coord[4]); - dst_coord[5] = srctoh32(src_coord[5]); - - add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - - curpos_src += 6 * sizeof(u32); - curpos_dst += 6 * sizeof(u32); - } - - curpos_dst = ALIGN8(curpos_dst); - - // vertices - uintptr_t ptr_src_vertices = curpos_src = ALIGN8(dst_header->ptr_vertices - src_ofs); - uintptr_t ptr_dst_vertices = curpos_dst + dst_roomoffset; - - add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - - uintptr_t vtx_end = dst_header->ptr_colours - src_ofs; - - while (dst_header->ptr_colours && curpos_src < vtx_end) { - struct vtx *src_vtx = (struct vtx*)(src + curpos_src); - struct vtx *dst_vtx = (struct vtx*)(dst + curpos_dst); - - dst_vtx->coord[0] = srctoh16(src_vtx->coord[0]); - dst_vtx->coord[1] = srctoh16(src_vtx->coord[1]); - dst_vtx->coord[2] = srctoh16(src_vtx->coord[2]); - - dst_vtx->flag = src_vtx->flag; - dst_vtx->color = src_vtx->color; - - dst_vtx->s = srctoh16(src_vtx->s); - dst_vtx->t = srctoh16(src_vtx->t); - - curpos_src += sizeof(struct vtx); - curpos_dst += sizeof(struct vtx); - } - - curpos_dst = ALIGN8(curpos_dst); - - // colors - uintptr_t ptr_src_colors = 0; - uintptr_t ptr_dst_colors = 0; - - if (dst_header->ptr_colours) { - ptr_src_colors = curpos_src = ALIGN8(dst_header->ptr_colours - src_ofs); - ptr_dst_colors = curpos_dst + dst_roomoffset; - - add_marker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - - uintptr_t col_end = numgdls > 0 != 0 ? gdls_addr[0] : infsize; - size_t col_len = col_end - curpos_src; - - memcpy(dst + curpos_dst, src + curpos_src, col_len); - curpos_src += col_len; - curpos_dst += col_len; - } - - // gdls - gbi_set_vtx(src_header->ptr_vertices, ptr_src_vertices); - gbi_set_segment(0x0e, dst_header->ptr_vertices); - - m_SizeGDLs = 0; - uintptr_t gdlstart = curpos_dst; - for (size_t i = 0; i < numgdls; i++) { - add_marker(gdls_addr[i] + src_ofs, curpos_dst + dst_roomoffset); - curpos_dst = gbi_convert_gdl(dst, curpos_dst, src, gdls_addr[i], 1); - } - m_SizeGDLs = curpos_dst - gdlstart; - - // relink ptrs: roomblocks - for (size_t i = 0; i < numblocks; i++) { - struct host_roomblock *block = (struct host_roomblock*)&ptr_dst_roomblocks[i]; - - relink_ptr(&block->ptr_next); - - if (block->type == BLOCK_LEAF) { - relink_ptr(&block->ptr_gdl); - u32 offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; - u32 offset_col = block->ptr_colours - ptr_src_colors - src_ofs; - - block->ptr_vertices = ptr_dst_vertices + offset_vtx; - block->ptr_colours = ptr_dst_colors + offset_col; - } - else { - relink_ptr(&block->ptr_gdl); // child - relink_ptr(&block->ptr_vertices); // coord - } - } - - // relink ptrs: header - relink_ptr(&dst_header->ptr_vertices); - relink_ptr(&dst_header->ptr_colours); - relink_ptr(&dst_header->ptr_opablocks); - relink_ptr(&dst_header->ptr_xlublocks); - - return curpos_dst; -} - -static u32 convert_section1(u8 *dst, u8 *src, u32 ofs) -{ - // Convert primary - u32 srcpos = 0; - u32 dstpos = 0; - struct host_primaryheader *host_primary_header = (struct host_primaryheader *) dst; - struct n64_primaryheader *n64_primary_header = (struct n64_primaryheader *) src; - srcpos += sizeof(struct n64_primaryheader); - dstpos += sizeof(*host_primary_header); - - u32 src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - ofs; - - host_primary_header->unused1 = 0; - host_primary_header->unused2 = 0; - - host_primary_header->ptr_rooms = dstpos + ofs; - convert_primary_rooms(dst, &dstpos, src, &srcpos); - - if (n64_primary_header->ptr_lights) { - host_primary_header->ptr_lights = dstpos + ofs; - srcpos = srctodst32(n64_primary_header->ptr_lights) - ofs; - convert_primary_lights(dst, &dstpos, src, &srcpos, src_bgcmds); - } - - host_primary_header->ptr_portals = dstpos + ofs; - srcpos = srctodst32(n64_primary_header->ptr_portals) - ofs; - u32 src_portalvtxs, dst_portalvtxs; - convert_primary_portals(dst, &dstpos, src, &srcpos, &src_portalvtxs, &dst_portalvtxs); - - host_primary_header->ptr_bgcmds = dstpos + ofs; - convert_primary_bgcmds(dst, &dstpos, &src[src_bgcmds], dst_portalvtxs, src_portalvtxs); - - return dstpos; -} - -static void convert_section2_texturenums(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 srclen) -{ - u16 *src_ids = (u16 *) &src[*srcpos]; - u16 *dst_ids = (u16 *) &dst[*dstpos]; - int count = srclen / sizeof(u16); - - for (int i = 0; i < count; i++) { - dst_ids[i] = srctodst16(src_ids[i]); - } - - *srcpos += srclen; - *dstpos += srclen; -} - -static void convert_section3_bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) -{ - s16 *src_bboxes = (s16 *) &src[*srcpos]; - s16 *dst_bboxes = (s16 *) &dst[*dstpos]; - - for (int i = 0; i < m_NumRooms; i++) { - dst_bboxes[i * 6 + 0] = srctodst16(src_bboxes[i * 6 + 0]); - dst_bboxes[i * 6 + 1] = srctodst16(src_bboxes[i * 6 + 1]); - dst_bboxes[i * 6 + 2] = srctodst16(src_bboxes[i * 6 + 2]); - dst_bboxes[i * 6 + 3] = srctodst16(src_bboxes[i * 6 + 3]); - dst_bboxes[i * 6 + 4] = srctodst16(src_bboxes[i * 6 + 4]); - dst_bboxes[i * 6 + 5] = srctodst16(src_bboxes[i * 6 + 5]); - } - - *srcpos += sizeof(s16) * 6 * (m_NumRooms - 1); - *dstpos += sizeof(s16) * 6 * (m_NumRooms - 1); -} - -static void convert_section3_allocsizes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) -{ - u16 *dst_sizes = (u16 *) &dst[*dstpos]; - - for (int i = 0; i < m_NumRooms; i++) { - dst_sizes[i] = (m_AllocSizes[i] - 0x100) / 0x10; - } - - *srcpos += sizeof(u16) * (m_NumRooms - 1); - *dstpos += sizeof(u16) * (m_NumRooms - 1); -} - -static void convert_section3_lightcounts(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) -{ - memcpy(&dst[*dstpos], &src[*srcpos], m_NumRooms); - - *srcpos += (m_NumRooms - 1); - *dstpos += (m_NumRooms - 1); -} - -void preprocessBgSection1(u8 *data, u32 size, u32 ofs) -{ - u8 *dst = sysMemZeroAlloc(size); - - u32 newSize = convert_section1(dst, data, ofs); - - if (newSize > size) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); - } - - memcpy(data, dst, newSize); - sysMemFree(dst); -} - -u32 preprocessBgRoom(u8 *data, u32 size, u32 room_ofs) -{ - size *= 2; - u8 *dst = sysMemZeroAlloc(size); - u32 newSize = convert_section1_roomgfxdata(dst, data, size, room_ofs); - - if (newSize > size) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg room, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); - } - - memcpy(data, dst, newSize); - sysMemFree(dst); - - return newSize; -} diff --git a/port/pdextract/ext_file_lang.c b/port/pdextract/ext_file_lang.c deleted file mode 100644 index fe518053c..000000000 --- a/port/pdextract/ext_file_lang.c +++ /dev/null @@ -1,95 +0,0 @@ -#include -#include -#include - -#include "common.h" -#include "romdata.h" -#include "system.h" - -static int get_next_nonzero(u8 *src, u32 offset, size_t len) -{ - u32 *ptr = (u32 *) &src[offset]; - u32 *end = (u32 *) &src[len]; - - while (ptr < end) { - if (*ptr != 0) { - return srctoh32(*ptr); - } - - ptr++; - } - - return 0; -} - -static int get_num_strings(u8 *src, size_t len) -{ - u32 ptr_table_len = get_next_nonzero(src, 0, len); - - if (ptr_table_len) { - return ptr_table_len / sizeof(u32); - } - - return 1; -} - -u32 convert_lang_file(u8 *dst, u8 *src, size_t srclen) -{ - // Convert it - u32 *src_offsets = (u32 *) src; - size_t src_ptr_table_len = srctoh32(src_offsets[0]); - size_t src_str_table_len = srclen - src_ptr_table_len; - int num_strings = get_num_strings(src, srclen); - size_t dst_ptr_table_len = num_strings * sizeof(uintptr_t); - size_t dst_str_table_len = src_str_table_len; - - int cur_dst_offset = dst_ptr_table_len; - - uintptr_t *dst_offsets = (uintptr_t *) dst; - - for (int i = 0; i < num_strings; i++) { - u32 src_offset = srctoh32(src_offsets[i]); - - if (src_offset) { - // Write pointer - dst_offsets[i] = htodst32(cur_dst_offset); - - // Write string - u32 end = get_next_nonzero(src, (i + 1) * 4, num_strings * 4); - - if (!end) { - end = srclen; - } - - size_t len = end - src_offset; - len = ALIGN4(len); - memcpy(&dst[cur_dst_offset], &src[src_offset], len); - - cur_dst_offset += len; - } else { - // Write pointer - dst_offsets[i] = 0; - } - } - - return ALIGN16(cur_dst_offset); -} - -u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_LANG); - u8 *dst = sysMemZeroAlloc(newSizeEstimated); - - u32 newSize = convert_lang_file(dst, data, size); - - if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a lang file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); - } - - memcpy(data, dst, newSize); - sysMemFree(dst); - - *outSize = newSize; - - return 0; -} diff --git a/port/pdextract/ext_file_model.c b/port/pdextract/ext_file_model.c deleted file mode 100644 index d9bb5c889..000000000 --- a/port/pdextract/ext_file_model.c +++ /dev/null @@ -1,1028 +0,0 @@ -#include -#include -#include - -#include "types.h" -#include "gbi.h" -#include "game/texdecompress.h" - -#include "common.h" -#include "romdata.h" -#include "system.h" - -enum contenttype { - /* 0*/ CT_MODELDEF, - /* 1*/ CT_NODE, - /* 2*/ CT_TEXCONFIG, - /* 3*/ CT_TEXDATA, - /* 4*/ CT_PARTS, - /* 5*/ CT_VTXCOL, - /* 6*/ CT_GDL, - /* 7*/ CT_RODATA_CHRINFO, - /* 8*/ CT_RODATA_POSITION, - /* 9*/ CT_RODATA_GUNDL, - /*10*/ CT_RODATA_DISTANCE, - /*11*/ CT_RODATA_REORDER, - /*12*/ CT_RODATA_BBOX, - /*13*/ CT_RODATA_CHRGUNFIRE, - /*14*/ CT_RODATA_11, - /*15*/ CT_RODATA_TOGGLE, - /*16*/ CT_RODATA_POSITIONHELD, - /*17*/ CT_RODATA_STARGUNFIRE, - /*18*/ CT_RODATA_HEADSPOT, - /*19*/ CT_RODATA_DL, - /*20*/ CT_RODATA_19, - /*21*/ CT_VTXCOL4, // CT_VTXCOL but aligned to 4 bytes instead of 8 -}; - -struct marker { - u32 src_offset; - u32 dst_offset; - u32 parent_src_offset; - enum contenttype type; -}; - -struct alignconfig { - int before; - int after; -}; - -struct alignconfig m_AlignConfigs[] = { - /* 0*/ { 16, 4 }, - /* 1*/ { 4, 4 }, - /* 2*/ { 4, 4 }, - /* 3*/ { 8, 8 }, // CT_TEXDATA - /* 4*/ { 4, 4 }, - /* 5*/ { 8, 4 }, // CT_VTXCOL - /* 6*/ { 8, 8 }, // CT_GDL - /* 7*/ { 4, 4 }, - /* 8*/ { 4, 4 }, - /* 9*/ { 8, 4 }, // CT_GUNDL - /*10*/ { 4, 4 }, - /*11*/ { 4, 4 }, - /*12*/ { 4, 4 }, - /*13*/ { 4, 4 }, - /*14*/ { 4, 4 }, - /*15*/ { 4, 4 }, - /*16*/ { 4, 4 }, - /*17*/ { 8, 4 }, // CT_STARGUNFIRE - /*18*/ { 4, 4 }, - /*19*/ { 8, 4 }, // CT_RODATA_DL - /*20*/ { 4, 4 }, - /*21*/ { 4, 4 }, -}; - -struct marker m_Markers[1024]; -int m_NumMarkers; - -struct src_modeldef { - u32 ptr_rootnode; - u32 ptr_skel; - u32 ptr_parts; - s16 numparts; - s16 nummatrices; - u32 scale; - u16 rwdatalen; - u16 numtexconfigs; - u32 ptr_texconfigs; -}; - -struct dst_modeldef { - uintptr_t ptr_rootnode; - uintptr_t ptr_skel; - uintptr_t ptr_parts; - s16 numparts; - s16 nummatrices; - u32 scale; - u16 rwdatalen; - u16 numtexconfigs; - uintptr_t ptr_texconfigs; -}; - -struct src_modelnode { - u16 type; - u32 ptr_rodata; - u32 ptr_parent; - u32 ptr_next; - u32 ptr_prev; - u32 ptr_child; -}; - -struct dst_modelnode { - u16 type; - uintptr_t ptr_rodata; - uintptr_t ptr_parent; - uintptr_t ptr_next; - uintptr_t ptr_prev; - uintptr_t ptr_child; -}; - -struct generic_rodata_chrinfo { - u16 animpart; - s16 mtxindex; - u32 unk04; - u16 rwdataindex; -}; - -struct generic_rodata_position { - u32 pos[3]; - u16 part; - s16 mtxindexes[3]; - u32 drawdist; -}; - -struct src_rodata_gundl { - u32 ptr_opagdl; - u32 ptr_xlugdl; - u32 ptr_baseaddr; - u32 ptr_vertices; - s16 numvertices; - s16 unk12; -}; - -struct dst_rodata_gundl { - uintptr_t ptr_opagdl; - uintptr_t ptr_xlugdl; - uintptr_t ptr_baseaddr; - uintptr_t ptr_vertices; - s16 numvertices; - s16 unk12; -}; - -struct src_rodata_distance { - u32 near; - u32 far; - u32 ptr_target; - u16 rwdataindex; -}; - -struct dst_rodata_distance { - u32 near; - u32 far; - uintptr_t ptr_target; - u16 rwdataindex; -}; - -struct src_rodata_reorder { - u32 unk00; - u32 unk04; - u32 unk08; - u32 unk0c[3]; - u32 ptr_node_unk18; - u32 ptr_node_unk1c; - s16 side; - u16 rwdataindex; -}; - -struct dst_rodata_reorder { - u32 unk00; - u32 unk04; - u32 unk08; - u32 unk0c[3]; - uintptr_t ptr_node_unk18; - uintptr_t ptr_node_unk1c; - s16 side; - u16 rwdataindex; -}; - -struct generic_rodata_bbox { - s32 hitpart; - u32 bbox[6]; -}; - -struct src_rodata_chrgunfire { - u32 pos[3]; - u32 dim[3]; - u32 ptr_texture; - u32 unk1c; - u16 rwdataindex; - u32 ptr_baseaddr; -}; - -struct dst_rodata_chrgunfire { - u32 pos[3]; - u32 dim[3]; - uintptr_t ptr_texture; - u32 unk1c; - u16 rwdataindex; - uintptr_t ptr_baseaddr; -}; - -struct src_rodata_type11 { - u32 unk00; - u32 unk04; - u32 unk08; - u32 unk0c; - u32 unk10; - u32 ptr_unk14; // not used - u32 extra1; - u32 extra2; -}; - -struct dst_rodata_type11 { - u32 unk00; - u32 unk04; - u32 unk08; - u32 unk0c; - u32 unk10; - u32 unk14; - u32 extra1; - u32 extra2; -}; - -struct src_rodata_toggle { - u32 ptr_target; - u16 rwdataindex; -}; - -struct dst_rodata_toggle { - uintptr_t ptr_target; - u16 rwdataindex; -}; - -struct generic_rodata_positionheld { - u32 pos[3]; - s16 mtxindex; - u32 unk10; -}; - -struct src_rodata_stargunfire { - u32 unk00; - u32 ptr_vertices; - u32 ptr_gdl; - u32 ptr_baseaddr; -}; - -struct dst_rodata_stargunfire { - u32 unk00; - uintptr_t ptr_vertices; - uintptr_t ptr_gdl; - uintptr_t ptr_baseaddr; -}; - -struct generic_rodata_headspot { - u16 rwdataindex; -}; - -struct src_rodata_dl { - u32 ptr_opagdl; - u32 ptr_xlugdl; - u32 ptr_colours; - u32 ptr_vertices; // colours follow this array - s16 numvertices; - s16 mcount; - u16 rwdataindex; - u16 numcolours; -}; - -struct dst_rodata_dl { - uintptr_t ptr_opagdl; - uintptr_t ptr_xlugdl; - uintptr_t ptr_colours; - uintptr_t ptr_vertices; // colours follow this array - s16 numvertices; - s16 mcount; - u16 rwdataindex; - u16 numcolours; -}; - -struct generic_rodata_type19 { - u32 numvertices; - u32 vertices[3]; -}; - -struct src_texconfig { - u32 ptr; - u8 width; - u8 height; - u8 level; - u8 format; - u8 depth; - u8 s; - u8 t; - u8 unk0b; -}; - -struct dst_texconfig { - uintptr_t ptr; - u8 width; - u8 height; - u8 level; - u8 format; - u8 depth; - u8 s; - u8 t; - u8 unk0b; -}; - -#define PD_PTR_BASE(x, b) (void *)((u8 *)b + (uintptr_t)x) -#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (uintptr_t)x) - - -static inline void *minPtr(void *a, void *b) { - return (a && (a < b || !b)) ? a : b; -} - -static inline void *minPtr3(void *a, void *b, void *c) { - return minPtr(minPtr(a, b), c); -} - -static struct marker *find_marker(u32 src_offset) -{ - for (int i = 0; i < m_NumMarkers; i++) { - if (m_Markers[i].src_offset == src_offset) { - return &m_Markers[i]; - } - } - - return NULL; -} - -static void set_marker(u32 src_offset, enum contenttype type, u32 parent_src_offset) -{ - if (src_offset == 0) { - return; - } - - src_offset &= 0x00ffffff; - - if (find_marker(src_offset)) { - return; - } - - if (m_NumMarkers >= ARRAYCOUNT(m_Markers)) { - fprintf(stderr, "Marker limit exceeded\n"); - exit(EXIT_FAILURE); - } - - m_Markers[m_NumMarkers].src_offset = src_offset; - m_Markers[m_NumMarkers].type = type; - m_Markers[m_NumMarkers].parent_src_offset = parent_src_offset; - m_NumMarkers++; -} - -enum contenttype m_NodeTypeToContentType[] = { - /*0x00*/ -1, - /*0x01*/ CT_RODATA_CHRINFO, - /*0x02*/ CT_RODATA_POSITION, - /*0x03*/ -1, - /*0x04*/ CT_RODATA_GUNDL, - /*0x05*/ -1, - /*0x06*/ -1, - /*0x07*/ -1, - /*0x08*/ CT_RODATA_DISTANCE, - /*0x09*/ CT_RODATA_REORDER, - /*0x0a*/ CT_RODATA_BBOX, - /*0x0b*/ -1, - /*0x0c*/ CT_RODATA_CHRGUNFIRE, - /*0x0d*/ -1, - /*0x0e*/ -1, - /*0x0f*/ -1, - /*0x10*/ -1, - /*0x11*/ CT_RODATA_11, - /*0x12*/ CT_RODATA_TOGGLE, - /*0x13*/ -1, - /*0x14*/ -1, - /*0x15*/ CT_RODATA_POSITIONHELD, - /*0x16*/ CT_RODATA_STARGUNFIRE, - /*0x17*/ CT_RODATA_HEADSPOT, - /*0x18*/ CT_RODATA_DL, - /*0x19*/ CT_RODATA_19, -}; - -static void populate_markers(u8 *src) -{ - m_NumMarkers = 0; - - set_marker(0x05000000, CT_MODELDEF, 0); - - for (int i = 0; i < m_NumMarkers; i++) { - struct marker *marker = &m_Markers[i]; - void *src_thing = &src[marker->src_offset]; - int numvtx = 0; - u32 colstart = 0; - - switch (marker->type) { - case CT_MODELDEF: - struct src_modeldef *src_modeldef = src_thing; - int num_texconfigs = srctoh16(src_modeldef->numtexconfigs); - u32 texconfigpos = srctoh32(src_modeldef->ptr_texconfigs); - set_marker(srctoh32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); - - for (int i = 0; i < num_texconfigs; i++) { - set_marker(texconfigpos + sizeof(struct src_texconfig) * i, CT_TEXCONFIG, marker->src_offset); - } - break; - case CT_NODE: - struct src_modelnode *src_node = src_thing; - u32 node_type = srctoh16(src_node->type) & 0xff; - set_marker(srctoh32(src_node->ptr_rodata), m_NodeTypeToContentType[node_type], marker->src_offset); - set_marker(srctoh32(src_node->ptr_parent), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_node->ptr_next), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_node->ptr_prev), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_node->ptr_child), CT_NODE, marker->src_offset); - break; - case CT_TEXCONFIG: - struct src_texconfig *src_texconfig = src_thing; - if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { - set_marker(srctoh32(src_texconfig->ptr), CT_TEXDATA, marker->src_offset); - } - break; - case CT_PARTS: - struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - u32 *src_parts = (u32 *) src_thing; - int num_parts = srctoh16(src_modeldef2->numparts); - - for (int i = 0; i < num_parts; i++) { - set_marker(srctoh32(src_parts[i]), CT_NODE, marker->src_offset); - } - break; - case CT_RODATA_CHRINFO: - break; - case CT_RODATA_POSITION: - break; - case CT_RODATA_GUNDL: - struct src_rodata_gundl *src_gundl = src_thing; - set_marker(srctoh32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); - set_marker(srctoh32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); - set_marker(srctoh32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); - break; - case CT_RODATA_DISTANCE: - struct src_rodata_distance *src_dist = src_thing; - set_marker(srctoh32(src_dist->ptr_target), CT_NODE, marker->src_offset); - break; - case CT_RODATA_REORDER: - struct src_rodata_reorder *src_reorder = src_thing; - set_marker(srctoh32(src_reorder->ptr_node_unk18), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_reorder->ptr_node_unk1c), CT_NODE, marker->src_offset); - break; - case CT_RODATA_CHRGUNFIRE: - struct src_rodata_chrgunfire *src_chrgunfire = src_thing; - set_marker(srctoh32(src_chrgunfire->ptr_texture), CT_TEXCONFIG, marker->src_offset); - break; - case CT_RODATA_TOGGLE: - struct src_rodata_toggle *src_toggle = src_thing; - set_marker(srctoh32(src_toggle->ptr_target), CT_NODE, marker->src_offset); - break; - case CT_RODATA_STARGUNFIRE: - struct src_rodata_stargunfire *src_stargunfire = src_thing; - colstart = srctoh32(src_stargunfire->unk00)*4*12; - u32 vtxstart = srctoh32(src_stargunfire->ptr_vertices); - colstart = ALIGN(vtxstart + colstart, 8); - - set_marker(srctoh32(src_stargunfire->ptr_vertices), CT_VTXCOL4, marker->src_offset); - set_marker(colstart, CT_VTXCOL4, marker->src_offset); - set_marker(srctoh32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); - break; - case CT_RODATA_DL: - struct src_rodata_dl *src_dl = src_thing; - set_marker(srctoh32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); - set_marker(srctoh32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); - set_marker(srctoh32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); - set_marker(srctoh32(src_dl->ptr_vertices), CT_VTXCOL, marker->src_offset); - break; - case CT_TEXDATA: - case CT_VTXCOL: - case CT_GDL: - case CT_RODATA_BBOX: - case CT_RODATA_11: - case CT_RODATA_POSITIONHELD: - case CT_RODATA_HEADSPOT: - case CT_RODATA_19: - break; - } - } -} - -static void sort_markers(void) -{ - for (int i = 0; i < m_NumMarkers - 1; i++) { - u32 min_offset = 0xffffffff; - int min_index = -1; - - for (int j = i + 1; j < m_NumMarkers; j++) { - if (m_Markers[j].src_offset < min_offset) { - min_offset = m_Markers[j].src_offset; - min_index = j; - } - } - - if (min_index >= 0 && m_Markers[min_index].src_offset < m_Markers[i].src_offset) { - struct marker tmp = m_Markers[i]; - m_Markers[i] = m_Markers[min_index]; - m_Markers[min_index] = tmp; - } - } -} - -static u32 convert_content(u8 *dst, u8 *src, u32 src_file_len) -{ - u32 dstpos = 0; - - for (int i = 0; i < m_NumMarkers; i++) { - struct marker *marker = &m_Markers[i]; - void *src_thing = &src[marker->src_offset]; - u32 src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; - u32 src_len = src_end - marker->src_offset; - - dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].before); - - marker->dst_offset = dstpos; - void *dst_thing = &dst[dstpos]; - - switch (marker->type) { - case CT_MODELDEF: - struct src_modeldef *src_modeldef = src_thing; - struct dst_modeldef *dst_modeldef = dst_thing; - dst_modeldef->ptr_skel = srctodst32(src_modeldef->ptr_skel); - dst_modeldef->numparts = srctodst16(src_modeldef->numparts); - dst_modeldef->nummatrices = srctodst16(src_modeldef->nummatrices); - dst_modeldef->scale = srctodst32(src_modeldef->scale); - dst_modeldef->rwdatalen = srctodst16(src_modeldef->rwdatalen); - dst_modeldef->numtexconfigs = srctodst16(src_modeldef->numtexconfigs); - dstpos += sizeof(*dst_modeldef); - break; - case CT_NODE: - struct src_modelnode *src_node = src_thing; - struct dst_modelnode *dst_node = dst_thing; - dst_node->type = srctodst16(src_node->type); - dstpos += sizeof(*dst_node); - break; - case CT_TEXCONFIG: - struct src_texconfig *src_texconfig = src_thing; - struct dst_texconfig *dst_texconfig = dst_thing; - - while (src_len >= sizeof(*src_texconfig)) { - if ((srctoh32(src_texconfig->ptr) & 0xff000000) != 0x05000000) { - dst_texconfig->ptr = srctodst32(src_texconfig->ptr); - } - - dst_texconfig->width = src_texconfig->width; - dst_texconfig->height = src_texconfig->height; - dst_texconfig->level = src_texconfig->level; - dst_texconfig->format = src_texconfig->format; - dst_texconfig->depth = src_texconfig->depth; - dst_texconfig->s = src_texconfig->s; - dst_texconfig->t = src_texconfig->t; - dst_texconfig->unk0b = src_texconfig->unk0b; - - dstpos += sizeof(*dst_texconfig); - src_len -= sizeof(*src_texconfig); - src_texconfig++; - dst_texconfig++; - } - break; - case CT_TEXDATA: - memcpy(dst_thing, src_thing, src_len); - dstpos += src_len; - break; - case CT_PARTS: - struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - u32 *src_parts = (u32 *) src_thing; - uintptr_t *dst_parts = (uintptr_t *) dst_thing; - int num_parts = srctoh16(src_modeldef2->numparts); - u16 *src_nums = (u16 *) &src_parts[num_parts]; - u16 *dst_nums = (u16 *) &dst_parts[num_parts]; - - for (int i = 0; i < num_parts; i++) { - dst_nums[i] = srctodst16(src_nums[i]); - } - dstpos += num_parts * sizeof(uintptr_t) + num_parts * sizeof(u16); - if (num_parts) { - dstpos = ALIGN8(dstpos); - } - break; - case CT_VTXCOL: - case CT_VTXCOL4: - memcpy(dst_thing, src_thing, src_len); - dstpos += src_len; - break; - case CT_GDL: - struct marker *parent = find_marker(marker->parent_src_offset); - u32 src_vtx; - u32 dst_vtx; - - if (parent->type == CT_RODATA_GUNDL) { - struct src_rodata_gundl *src_rodata = (struct src_rodata_gundl *) &src[parent->src_offset]; - struct dst_rodata_gundl *dst_rodata = (struct dst_rodata_gundl *) &dst[parent->dst_offset]; - src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; - } else if (parent->type == CT_RODATA_STARGUNFIRE) { - struct src_rodata_stargunfire *src_rodata = (struct src_rodata_stargunfire *) &src[parent->src_offset]; - struct dst_rodata_stargunfire *dst_rodata = (struct dst_rodata_stargunfire *) &dst[parent->dst_offset]; - src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; - } else if (parent->type == CT_RODATA_DL) { - struct src_rodata_dl *src_rodata = (struct src_rodata_dl *) &src[parent->src_offset]; - struct dst_rodata_dl *dst_rodata = (struct dst_rodata_dl *) &dst[parent->dst_offset]; - src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; - } - - dstpos = gbi_convert_gdl(dst, dstpos, src, marker->src_offset, 0); - break; - case CT_RODATA_CHRINFO: - struct generic_rodata_chrinfo *src_chrinfo = src_thing; - struct generic_rodata_chrinfo *dst_chrinfo = dst_thing; - dst_chrinfo->animpart = srctodst16(src_chrinfo->animpart); - dst_chrinfo->mtxindex = srctodst16(src_chrinfo->mtxindex); - dst_chrinfo->unk04 = srctodst32(src_chrinfo->unk04); - dst_chrinfo->rwdataindex = srctodst16(src_chrinfo->rwdataindex); - dstpos += sizeof(*dst_chrinfo); - break; - case CT_RODATA_POSITION: - struct generic_rodata_position *src_position = src_thing; - struct generic_rodata_position *dst_position = dst_thing; - dst_position->pos[0] = srctodst32(src_position->pos[0]); - dst_position->pos[1] = srctodst32(src_position->pos[1]); - dst_position->pos[2] = srctodst32(src_position->pos[2]); - dst_position->part = srctodst16(src_position->part); - dst_position->mtxindexes[0] = srctodst16(src_position->mtxindexes[0]); - dst_position->mtxindexes[1] = srctodst16(src_position->mtxindexes[1]); - dst_position->mtxindexes[2] = srctodst16(src_position->mtxindexes[2]); - dst_position->drawdist = srctodst32(src_position->drawdist); - dstpos += sizeof(*dst_position); - break; - case CT_RODATA_GUNDL: - struct src_rodata_gundl *src_gundl = src_thing; - struct dst_rodata_gundl *dst_gundl = dst_thing; - dst_gundl->ptr_vertices = 0; - dst_gundl->numvertices = srctodst16(src_gundl->numvertices); - dst_gundl->unk12 = srctodst16(src_gundl->unk12); - dstpos += sizeof(*dst_gundl); - break; - case CT_RODATA_DISTANCE: - struct src_rodata_distance *src_dist = src_thing; - struct dst_rodata_distance *dst_dist = dst_thing; - dst_dist->near = srctodst32(src_dist->near); - dst_dist->far = srctodst32(src_dist->far); - dst_dist->rwdataindex = srctodst16(src_dist->rwdataindex); - dstpos += sizeof(*dst_dist); - break; - case CT_RODATA_REORDER: - struct src_rodata_reorder *src_reorder = src_thing; - struct dst_rodata_reorder *dst_reorder = dst_thing; - dst_reorder->unk00 = srctodst32(src_reorder->unk00); - dst_reorder->unk04 = srctodst32(src_reorder->unk04); - dst_reorder->unk08 = srctodst32(src_reorder->unk08); - dst_reorder->unk0c[0] = srctodst32(src_reorder->unk0c[0]); - dst_reorder->unk0c[1] = srctodst32(src_reorder->unk0c[1]); - dst_reorder->unk0c[2] = srctodst32(src_reorder->unk0c[2]); - dst_reorder->side = srctodst16(src_reorder->side); - dst_reorder->rwdataindex = srctodst16(src_reorder->rwdataindex); - dstpos += sizeof(*dst_reorder); - break; - case CT_RODATA_BBOX: - struct generic_rodata_bbox *src_bbox = src_thing; - struct generic_rodata_bbox *dst_bbox = dst_thing; - dst_bbox->hitpart = srctodst32(src_bbox->hitpart); - dst_bbox->bbox[0] = srctodst32(src_bbox->bbox[0]); - dst_bbox->bbox[1] = srctodst32(src_bbox->bbox[1]); - dst_bbox->bbox[2] = srctodst32(src_bbox->bbox[2]); - dst_bbox->bbox[3] = srctodst32(src_bbox->bbox[3]); - dst_bbox->bbox[4] = srctodst32(src_bbox->bbox[4]); - dst_bbox->bbox[5] = srctodst32(src_bbox->bbox[5]); - dstpos += sizeof(*dst_bbox); - break; - case CT_RODATA_CHRGUNFIRE: - struct src_rodata_chrgunfire *src_chrgunfire = src_thing; - struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; - dst_chrgunfire->pos[0] = srctodst32(src_chrgunfire->pos[0]); - dst_chrgunfire->pos[1] = srctodst32(src_chrgunfire->pos[1]); - dst_chrgunfire->pos[2] = srctodst32(src_chrgunfire->pos[2]); - dst_chrgunfire->dim[0] = srctodst32(src_chrgunfire->dim[0]); - dst_chrgunfire->dim[1] = srctodst32(src_chrgunfire->dim[1]); - dst_chrgunfire->dim[2] = srctodst32(src_chrgunfire->dim[2]); - dst_chrgunfire->unk1c = srctodst32(src_chrgunfire->unk1c); - dst_chrgunfire->rwdataindex = srctodst16(src_chrgunfire->rwdataindex); - dst_chrgunfire->ptr_baseaddr = 0; - dstpos += sizeof(*dst_chrgunfire); - break; - case CT_RODATA_11: - struct src_rodata_type11 *src_type11 = src_thing; - struct dst_rodata_type11 *dst_type11 = dst_thing; - dst_type11->unk00 = srctodst32(src_type11->unk00); - dst_type11->unk04 = srctodst32(src_type11->unk04); - dst_type11->unk08 = srctodst32(src_type11->unk08); - dst_type11->unk0c = srctodst32(src_type11->unk0c); - dst_type11->unk10 = srctodst32(src_type11->unk10); - dst_type11->extra1 = srctodst32(src_type11->extra1); - dst_type11->extra2 = srctodst32(src_type11->extra2); - dstpos += sizeof(*dst_type11); - break; - case CT_RODATA_TOGGLE: - struct src_rodata_toggle *src_toggle = src_thing; - struct dst_rodata_toggle *dst_toggle = dst_thing; - dst_toggle->rwdataindex = srctodst16(src_toggle->rwdataindex); - dstpos += sizeof(*dst_toggle); - break; - case CT_RODATA_POSITIONHELD: - struct generic_rodata_positionheld *src_posheld = src_thing; - struct generic_rodata_positionheld *dst_posheld = dst_thing; - dst_posheld->pos[0] = srctodst32(src_posheld->pos[0]); - dst_posheld->pos[1] = srctodst32(src_posheld->pos[1]); - dst_posheld->pos[2] = srctodst32(src_posheld->pos[2]); - dst_posheld->mtxindex = srctodst16(src_posheld->mtxindex); - dst_posheld->unk10 = srctodst32(src_posheld->unk10); - dstpos += sizeof(*dst_posheld); - break; - case CT_RODATA_STARGUNFIRE: - struct src_rodata_stargunfire *src_stargunfire = src_thing; - struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; - dst_stargunfire->unk00 = srctodst32(src_stargunfire->unk00); - dstpos += sizeof(*dst_stargunfire); - break; - case CT_RODATA_HEADSPOT: - struct generic_rodata_headspot *src_headspot = src_thing; - struct generic_rodata_headspot *dst_headspot = dst_thing; - dst_headspot->rwdataindex = srctodst16(src_headspot->rwdataindex); - dstpos += sizeof(*dst_headspot); - break; - case CT_RODATA_DL: - struct src_rodata_dl *src_dl = src_thing; - struct dst_rodata_dl *dst_dl = dst_thing; - dst_dl->numvertices = srctodst16(src_dl->numvertices); - dst_dl->mcount = srctodst16(src_dl->mcount); - dst_dl->rwdataindex = srctodst16(src_dl->rwdataindex); - dst_dl->numcolours = srctodst16(src_dl->numcolours); - dstpos += sizeof(*dst_dl); - break; - case CT_RODATA_19: - struct generic_rodata_type19 *src_type19 = src_thing; - struct generic_rodata_type19 *dst_type19 = dst_thing; - u32 *src_vertices = src_thing + sizeof(u32); - u32 *dst_vertices = dst_thing + sizeof(u32); - int num_vertices = srctoh32(src_type19->numvertices); - - dst_type19->numvertices = htodst32(num_vertices); - dstpos += sizeof(u32); - - for (int i = 0; i < num_vertices; i++) { - dst_vertices[i * 3 + 0] = srctodst32(src_vertices[i * 3 + 0]); - dst_vertices[i * 3 + 1] = srctodst32(src_vertices[i * 3 + 1]); - dst_vertices[i * 3 + 2] = srctodst32(src_vertices[i * 3 + 2]); - dstpos += sizeof(u32) * 3; - } - break; - } - - dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].after); - } - - return dstpos; -} - -static u32 resolve_pointer(u32 src_offset) -{ - if (src_offset == 0) { - return 0; - } - - struct marker *marker = find_marker(src_offset & 0x00ffffff); - return marker ? (0x05000000 | marker->dst_offset) : 0; -} - -static u8 *relink_pointers(u8 *dst, u8 *src) -{ - u8 *textures_end = 0; - - for (int i = 0; i < m_NumMarkers; i++) { - struct marker *marker = &m_Markers[i]; - void *src_thing = &src[marker->src_offset]; - void *dst_thing = &dst[marker->dst_offset]; - - u8 *lowestptr = 0; - - switch (marker->type) { - case CT_MODELDEF: - struct src_modeldef *src_modeldef = src_thing; - struct dst_modeldef *dst_modeldef = dst_thing; - dst_modeldef->ptr_rootnode = htodst32(resolve_pointer(srctoh32(src_modeldef->ptr_rootnode))); - dst_modeldef->ptr_parts = htodst32(resolve_pointer(srctoh32(src_modeldef->ptr_parts))); - dst_modeldef->ptr_texconfigs = htodst32(resolve_pointer(srctoh32(src_modeldef->ptr_texconfigs))); - break; - case CT_NODE: - struct src_modelnode *src_node = src_thing; - struct dst_modelnode *dst_node = dst_thing; - dst_node->ptr_rodata = htodst32(resolve_pointer(srctoh32(src_node->ptr_rodata))); - dst_node->ptr_parent = htodst32(resolve_pointer(srctoh32(src_node->ptr_parent))); - dst_node->ptr_next = htodst32(resolve_pointer(srctoh32(src_node->ptr_next))); - dst_node->ptr_prev = htodst32(resolve_pointer(srctoh32(src_node->ptr_prev))); - dst_node->ptr_child = htodst32(resolve_pointer(srctoh32(src_node->ptr_child))); - - lowestptr = dst_node->ptr_rodata; - break; - case CT_TEXCONFIG: - struct src_texconfig *src_texconfig = src_thing; - struct dst_texconfig *dst_texconfig = dst_thing; - if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { - dst_texconfig->ptr = htodst32(resolve_pointer(srctoh32(src_texconfig->ptr))); - gbi_add_tex_addr(srctoh32(src_texconfig->ptr), dst_texconfig->ptr); - } - break; - case CT_PARTS: - struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; - u32 *src_parts = (u32 *) src_thing; - uintptr_t *dst_parts = (uintptr_t *) dst_thing; - int num_parts = srctoh16(src_modeldef2->numparts); - - for (int i = 0; i < num_parts; i++) { - dst_parts[i] = htodst32(resolve_pointer(srctoh32(src_parts[i]))); - } - break; - case CT_RODATA_CHRINFO: - break; - case CT_RODATA_POSITION: - break; - case CT_RODATA_GUNDL: - struct src_rodata_gundl *src_gundl = src_thing; - struct dst_rodata_gundl *dst_gundl = dst_thing; - dst_gundl->ptr_opagdl = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_opagdl))); - dst_gundl->ptr_xlugdl = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_xlugdl))); - dst_gundl->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_gundl->ptr_vertices))); - - gbi_convert_vtx(dst, dst_gundl->ptr_vertices & 0x00ffffff, dst_gundl->numvertices); - - gbi_set_vtx(srctoh32(src_gundl->ptr_vertices), dst_gundl->ptr_vertices); - gbi_set_segment(0x04, dst_gundl->ptr_vertices); - - gbi_gdl_rewrite_addrs(dst, dst_gundl->ptr_opagdl); - gbi_gdl_rewrite_addrs(dst, dst_gundl->ptr_xlugdl); - - if (dst_gundl->ptr_opagdl) dst_gundl->ptr_opagdl |= 1; - if (dst_gundl->ptr_xlugdl) dst_gundl->ptr_xlugdl |= 1; - - lowestptr = minPtr3(dst_gundl->ptr_opagdl, dst_gundl->ptr_xlugdl, dst_gundl->ptr_vertices); - break; - case CT_RODATA_DISTANCE: - struct src_rodata_distance *src_dist = src_thing; - struct dst_rodata_distance *dst_dist = dst_thing; - dst_dist->ptr_target = htodst32(resolve_pointer(srctoh32(src_dist->ptr_target))); - break; - case CT_RODATA_REORDER: - struct src_rodata_reorder *src_reorder = src_thing; - struct dst_rodata_reorder *dst_reorder = dst_thing; - dst_reorder->ptr_node_unk18 = htodst32(resolve_pointer(srctoh32(src_reorder->ptr_node_unk18))); - dst_reorder->ptr_node_unk1c = htodst32(resolve_pointer(srctoh32(src_reorder->ptr_node_unk1c))); - break; - case CT_RODATA_CHRGUNFIRE: - struct src_rodata_chrgunfire *src_chrgunfire = src_thing; - struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; - dst_chrgunfire->ptr_texture = htodst32(resolve_pointer(srctoh32(src_chrgunfire->ptr_texture))); - if ((srctoh32(dst_chrgunfire->ptr_texture) & 0xff000000) == 0x05000000) { - gbi_add_tex_addr(srctoh32(dst_chrgunfire->ptr_texture), dst_chrgunfire->ptr_texture); - } - break; - case CT_RODATA_TOGGLE: - struct src_rodata_toggle *src_toggle = src_thing; - struct dst_rodata_toggle *dst_toggle = dst_thing; - dst_toggle->ptr_target = htodst32(resolve_pointer(srctoh32(src_toggle->ptr_target))); - break; - case CT_RODATA_STARGUNFIRE: - struct src_rodata_stargunfire *src_stargunfire = src_thing; - struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; - dst_stargunfire->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_stargunfire->ptr_vertices))); - dst_stargunfire->ptr_gdl = htodst32(resolve_pointer(srctoh32(src_stargunfire->ptr_gdl))); - - gbi_convert_vtx(dst, dst_stargunfire->ptr_vertices & 0x00ffffff, dst_stargunfire->unk00*4); - - gbi_set_vtx(srctoh32(src_stargunfire->ptr_vertices), dst_stargunfire->ptr_vertices); - gbi_set_segment(0x04, dst_stargunfire->ptr_vertices); - gbi_gdl_rewrite_addrs(dst, dst_stargunfire->ptr_gdl); - if (dst_stargunfire->ptr_gdl) dst_stargunfire->ptr_gdl |= 1; - - lowestptr = minPtr(dst_stargunfire->ptr_gdl, dst_stargunfire->ptr_vertices); - break; - case CT_RODATA_DL: - struct src_rodata_dl *src_dl = src_thing; - struct dst_rodata_dl *dst_dl = dst_thing; - dst_dl->ptr_opagdl = htodst32(resolve_pointer(srctoh32(src_dl->ptr_opagdl))); - dst_dl->ptr_xlugdl = htodst32(resolve_pointer(srctoh32(src_dl->ptr_xlugdl))); - dst_dl->ptr_colours = htodst32(resolve_pointer(srctoh32(src_dl->ptr_colours))); - dst_dl->ptr_vertices = htodst32(resolve_pointer(srctoh32(src_dl->ptr_vertices))); - - gbi_convert_vtx(dst, dst_dl->ptr_vertices & 0x00ffffff, dst_dl->numvertices); - - gbi_set_vtx(srctoh32(src_dl->ptr_vertices), dst_dl->ptr_vertices); - gbi_set_segment(0x04, dst_dl->ptr_vertices); - gbi_gdl_rewrite_addrs(dst, dst_dl->ptr_opagdl); - gbi_gdl_rewrite_addrs(dst, dst_dl->ptr_xlugdl); - - if (dst_dl->ptr_opagdl) dst_dl->ptr_opagdl |= 1; - if (dst_dl->ptr_xlugdl) dst_dl->ptr_xlugdl |= 1; - - lowestptr = minPtr3(dst_dl->ptr_opagdl, dst_dl->ptr_xlugdl, dst_dl->ptr_colours); - lowestptr = minPtr(lowestptr, dst_dl->ptr_vertices); - break; - case CT_TEXDATA: - case CT_VTXCOL: - case CT_GDL: - case CT_RODATA_BBOX: - case CT_RODATA_11: - case CT_RODATA_POSITIONHELD: - case CT_RODATA_HEADSPOT: - case CT_RODATA_19: - break; - } - - textures_end = minPtr(textures_end, lowestptr); - } - - return textures_end; -} - -static int convert_model(u8 *dst, u8 *src, u32 srclen) -{ - u32 dstpos; - - populate_markers(src); - sort_markers(); - - dstpos = convert_content(dst, src, srclen); - u8 *tex_end = relink_pointers(dst, src); - preprocess_textures(dst, tex_end); - - return dstpos; -} - -void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) -{ - for (uint32_t i = 0; i < size_bytes; i += 4, ++dest) { - *dest = PD_BE32(*dest); - } -} - -void preprocess_textures(u8 *base, u8 *textures_end) -{ - struct modeldef* mdl = (struct modeldef*)base; - if (!mdl->texconfigs) return; - - u32 ofs = 0x5000000; - struct textureconfig* texconfigs = PD_PTR_BASEOFS(mdl->texconfigs, base, ofs); - for (s16 i = 0; i < mdl->numtexconfigs; ++i) { - if ((texconfigs[i].texturenum & 0xf000000) == 0x5000000) { - // embedded texture; we need to unswizzle this - u8* texdata = PD_PTR_BASEOFS(texconfigs[i].textureptr, base, ofs); - // figure out the max possible size the texture can have, because sometimes the texconfig is wrong - const u32 maxSize = (textures_end > texconfigs[i].textureptr) ? (textures_end - texconfigs[i].textureptr) : 0; - // figure out the format and unswizzle - const s32 format = texConfigToFormat(&texconfigs[i]); - texSwizzleInternal(texdata, texconfigs[i].width, texconfigs[i].height, format, maxSize); - - if (format == TEXFORMAT_RGBA32) { - // for some reason, RGBA32 embedded textures don't need to be byte-swapped, - // so we byte-swap them here, which will be undone when the renderer imports it - u32 size_bytes = texconfigs[i].width * texconfigs[i].height * 4; - preprocessTextureRGBA32Embedded((u32*)texdata, size_bytes); - } - } - } -} - -u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize) -{ - gbi_reset(); - - u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_MODEL); - u8 *dst = sysMemZeroAlloc(newSizeEstimated); - - u32 newSize = convert_model(dst, data, size); - - if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); - } - - memcpy(data, dst, newSize); - sysMemFree(dst); - - *outSize = newSize; - - return 0; -} - -u8 *preprocessGunFile(u8 *data, u32 size, u32 *outSize) -{ - gbi_reset(); - - u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_MODEL); - u8 *dst = sysMemZeroAlloc(newSizeEstimated+128); - - u32 newSize = convert_model(dst, data, size); - - if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); - } - - memcpy(data, dst, newSize); - sysMemFree(dst); - - *outSize = newSize; - - return 0; -} - -#undef PD_PTR_BASE -#undef PD_PTR_BASEOFS diff --git a/port/pdextract/ext_file_pads.c b/port/pdextract/ext_file_pads.c deleted file mode 100644 index ef7632e1c..000000000 --- a/port/pdextract/ext_file_pads.c +++ /dev/null @@ -1,330 +0,0 @@ -#include -#include -#include - -#include "common.h" -#include "romdata.h" -#include "system.h" - -#define PADFLAG_INTPOS 0x0001 -#define PADFLAG_UPALIGNTOX 0x0002 -#define PADFLAG_UPALIGNTOY 0x0004 -#define PADFLAG_UPALIGNTOZ 0x0008 -#define PADFLAG_UPALIGNINVERT 0x0010 -#define PADFLAG_LOOKALIGNTOX 0x0020 -#define PADFLAG_LOOKALIGNTOY 0x0040 -#define PADFLAG_LOOKALIGNTOZ 0x0080 -#define PADFLAG_LOOKALIGNINVERT 0x0100 -#define PADFLAG_HASBBOXDATA 0x0200 - -struct n64_header { - s32 num_pads; - s32 num_covers; - u32 ptr_waypoints; - u32 ptr_waygroups; - u32 ptr_cover; -}; - -struct host_header { - s32 num_pads; - s32 num_covers; - uintptr_t ptr_waypoints; - uintptr_t ptr_waygroups; - uintptr_t ptr_cover; -}; - -struct padheader { - u32 flags : 18; - u32 room : 10; - u32 liftnum : 4; -}; - -struct n64_waypoint { - s32 padnum; - u32 ptr_neighbours; - s32 groupnum; - s32 step; -}; - -struct host_waypoint { - s32 padnum; - uintptr_t ptr_neighbours; - s32 groupnum; - s32 step; -}; - -struct n64_waygroup { - u32 ptr_neighbours; - u32 ptr_waypoints; - s32 step; -}; - -struct host_waygroup { - uintptr_t ptr_neighbours; - uintptr_t ptr_waypoints; - s32 step; -}; - -struct coverdefinition { - u32 pos[3]; - u32 dir[3]; - u16 flags; - u16 unk1a; -}; - -static int convert_pads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) -{ - u16 *src_offsets = (u16 *) &src[srcpos]; - u16 *dst_offsets = (u16 *) &dst[dstpos]; - - dstpos += num_pads * sizeof(u16); - - for (int i = 0; i < num_pads; i++) { - dstpos = ALIGN4(dstpos); - srcpos = srctoh16(src_offsets[i]); - - dst_offsets[i] = htodst16(dstpos); - - // Header - u32 n64_padheader = srctoh32(*(u32 *) &src[srcpos]); - struct padheader *host_padheader = (struct padheader *) &dst[dstpos]; - u32 flags = (n64_padheader >> 14) & 0x3ffff; - - *(u32*)host_padheader = htodst32(n64_padheader); - - srcpos += sizeof(struct padheader); - dstpos += sizeof(struct padheader); - - // Position - if (flags & PADFLAG_INTPOS) { - s16 *srcptr = (s16 *) &src[srcpos]; - s16 *dstptr = (s16 *) &dst[dstpos]; - - dstptr[0] = srctodst16(srcptr[0]); - dstptr[1] = srctodst16(srcptr[1]); - dstptr[2] = srctodst16(srcptr[2]); - - srcpos += 8; - dstpos += 8; - } else { - u32 *srcptr = (u32 *) &src[srcpos]; - u32 *dstptr = (u32 *) &dst[dstpos]; - - dstptr[0] = srctodst32(srcptr[0]); - dstptr[1] = srctodst32(srcptr[1]); - dstptr[2] = srctodst32(srcptr[2]); - - srcpos += 12; - dstpos += 12; - } - - // Up - if ((flags & (PADFLAG_UPALIGNTOX | PADFLAG_UPALIGNTOY | PADFLAG_UPALIGNTOZ)) == 0) { - u32 *srcptr = (u32 *) &src[srcpos]; - u32 *dstptr = (u32 *) &dst[dstpos]; - - dstptr[0] = srctodst32(srcptr[0]); - dstptr[1] = srctodst32(srcptr[1]); - dstptr[2] = srctodst32(srcptr[2]); - - srcpos += 12; - dstpos += 12; - } - - // Look - if ((flags & (PADFLAG_LOOKALIGNTOX | PADFLAG_LOOKALIGNTOY | PADFLAG_LOOKALIGNTOZ)) == 0) { - u32 *srcptr = (u32 *) &src[srcpos]; - u32 *dstptr = (u32 *) &dst[dstpos]; - - dstptr[0] = srctodst32(srcptr[0]); - dstptr[1] = srctodst32(srcptr[1]); - dstptr[2] = srctodst32(srcptr[2]); - - srcpos += 12; - dstpos += 12; - } - - // Bbox - if (flags & PADFLAG_HASBBOXDATA) { - u32 *srcptr = (u32 *) &src[srcpos]; - u32 *dstptr = (u32 *) &dst[dstpos]; - - dstptr[0] = srctodst32(srcptr[0]); - dstptr[1] = srctodst32(srcptr[1]); - dstptr[2] = srctodst32(srcptr[2]); - dstptr[3] = srctodst32(srcptr[3]); - dstptr[4] = srctodst32(srcptr[4]); - dstptr[5] = srctodst32(srcptr[5]); - - srcpos += 4 * 6; - dstpos += 4 * 6; - } - } - - return dstpos; -} - -static int convert_waypoints(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct n64_waypoint *n64_waypoints = (struct n64_waypoint *) &src[srcpos]; - struct host_waypoint *host_waypoints = (struct host_waypoint *) &dst[dstpos]; - int num_waypoints; - - for (num_waypoints = 0; n64_waypoints[num_waypoints].padnum != -1; num_waypoints++); - - dstpos += (num_waypoints + 1) * sizeof(struct host_waypoint); - - u32 *host_neighbours = (u32 *) &dst[dstpos]; - int n = 0; - - for (int i = 0; i < num_waypoints; i++) { - host_waypoints[i].padnum = srctodst32(n64_waypoints[i].padnum); - host_waypoints[i].ptr_neighbours = htodst32(dstpos); - host_waypoints[i].groupnum = srctodst32(n64_waypoints[i].groupnum); - host_waypoints[i].step = 0; - - u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waypoints[i].ptr_neighbours)]; - - for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { - host_neighbours[n++] = srctodst32(n64_neighbours[j]); - dstpos += 4; - } - - host_neighbours[n++] = 0xffffffff; - dstpos += 4; - } - - // Terminator - host_waypoints[num_waypoints].padnum = 0xffffffff; - host_waypoints[num_waypoints].ptr_neighbours = 0; - host_waypoints[num_waypoints].groupnum = 0; - host_waypoints[num_waypoints].step = 0; - - return dstpos; -} - -static int convert_waygroups(u8 *dst, int dstpos, u8 *src, int srcpos) -{ - struct n64_waygroup *n64_waygroups = (struct n64_waygroup *) &src[srcpos]; - struct host_waygroup *host_waygroups = (struct host_waygroup *) &dst[dstpos]; - int num_waygroups; - - for (num_waygroups = 0; n64_waygroups[num_waygroups].ptr_neighbours != 0; num_waygroups++); - - dstpos += (num_waygroups + 1) * sizeof(struct host_waygroup); - - // Waygroups and child waypoints - u32 *host_waypoints = (u32 *) &dst[dstpos]; - int n = 0; - - for (int i = 0; i < num_waygroups; i++) { - host_waygroups[i].ptr_waypoints = htodst32(dstpos); - host_waygroups[i].step = 0; - - u32 *n64_waypoints = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_waypoints)]; - - for (int j = 0; n64_waypoints[j] != 0xffffffff; j++) { - host_waypoints[n++] = srctodst32(n64_waypoints[j]); - dstpos += 4; - } - - host_waypoints[n++] = 0xffffffff; - dstpos += 4; - } - - // Terminator - host_waygroups[num_waygroups].ptr_neighbours = 0; - host_waygroups[num_waygroups].ptr_waypoints = 0; - host_waygroups[num_waygroups].step = 0; - - // Waygroup neighbours - u32 *host_neighbours = (u32 *) &dst[dstpos]; - n = 0; - - for (int i = 0; i < num_waygroups; i++) { - host_waygroups[i].ptr_neighbours = htodst32(dstpos); - - u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_neighbours)]; - - for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { - host_neighbours[n++] = srctodst32(n64_neighbours[j]); - dstpos += 4; - } - - host_neighbours[n++] = 0xffffffff; - dstpos += 4; - } - - return dstpos; -} - -static int convert_cover(u8 *dst, int dstpos, u8 *src, int srcpos, int num_covers) -{ - struct coverdefinition *n64_covers = (struct coverdefinition *) &src[srcpos]; - struct coverdefinition *host_covers = (struct coverdefinition *) &dst[dstpos]; - - for (int i = 0; i < num_covers; i++) { - host_covers[i].pos[0] = srctodst32(n64_covers[i].pos[0]); - host_covers[i].pos[1] = srctodst32(n64_covers[i].pos[1]); - host_covers[i].pos[2] = srctodst32(n64_covers[i].pos[2]); - host_covers[i].dir[0] = srctodst32(n64_covers[i].dir[0]); - host_covers[i].dir[1] = srctodst32(n64_covers[i].dir[1]); - host_covers[i].dir[2] = srctodst32(n64_covers[i].dir[2]); - host_covers[i].flags = srctodst16(n64_covers[i].flags); - host_covers[i].unk1a = srctodst16(n64_covers[i].unk1a); - } - - dstpos += num_covers * sizeof(struct coverdefinition); - - return dstpos; -} - -static int convert_pads_file(u8 *dst, u8 *src) -{ - int dstpos = 0; - struct n64_header *n64_header = (struct n64_header *) src; - struct host_header *host_header = (struct host_header *) dst; - - int num_pads = srctoh32(n64_header->num_pads); - int num_covers = srctoh32(n64_header->num_covers); - host_header->num_pads = htodst32(num_pads); - host_header->num_covers = htodst32(num_covers); - - dstpos += sizeof(struct host_header); - - // Pads - dstpos = convert_pads(dst, dstpos, src, sizeof(struct n64_header), num_pads); - - // Waypoints - host_header->ptr_waypoints = htodst32(dstpos); - dstpos = convert_waypoints(dst, dstpos, src, srctoh32(n64_header->ptr_waypoints)); - - // Waygroups - host_header->ptr_waygroups = htodst32(dstpos); - dstpos = convert_waygroups(dst, dstpos, src, srctoh32(n64_header->ptr_waygroups)); - - // Cover - host_header->ptr_cover = htodst32(dstpos); - dstpos = convert_cover(dst, dstpos, src, srctoh32(n64_header->ptr_cover), num_covers); - - return dstpos; -} - -u8* preprocessPadsFile(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_PADS); - u8* dst = sysMemZeroAlloc(newSizeEstimated); - - u32 newSize = convert_pads_file(dst, data); - - if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a pads file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); - } - - memcpy(data, dst, newSize); - sysMemFree(dst); - - *outSize = newSize; - - return 0; -} diff --git a/port/pdextract/ext_file_tiles.c b/port/pdextract/ext_file_tiles.c deleted file mode 100644 index 8e3c152aa..000000000 --- a/port/pdextract/ext_file_tiles.c +++ /dev/null @@ -1,107 +0,0 @@ -#include -#include -#include - -#include "common.h" -#include "romdata.h" -#include "system.h" - - -struct tile { - u8 type; - u8 numvertices; - u16 flags; - u16 floortype; - u8 xmin; - u8 ymin; - u8 zmin; - u8 xmax; - u8 ymax; - u8 zmax; - u16 floorcol; -}; - -u32 convert_tiles(u8 *dst, u8 *src, size_t srclen) -{ - int num_rooms = srctoh32(*(u32 *) src); - - size_t src_ptr_table_len = (num_rooms + 1) * 4; - size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(u32); - - u32 *src_offsets = (u32 *) &src[4]; - - size_t data_len = srclen - src_ptr_table_len - 4; - - *(u32 *) dst = htodst32(num_rooms); - - u32 *dst_offsets = (u32 *) (dst + sizeof(u32)); - u32 cur_dst_offset = dst_ptr_table_len + sizeof(u32); - - u32 cur_src_offset = srctoh32(src_offsets[0]); - u32 end_src_offset = srctoh32(src_offsets[num_rooms]); - int room = 0; - - while (1) { - // Check if this is a new room and write the pointer offset if so - while (room < (num_rooms + 1) && srctoh32(src_offsets[room]) == cur_src_offset) { - dst_offsets[room] = htodst32(cur_dst_offset); - room++; - } - - if (cur_src_offset >= end_src_offset) { - break; - } - - // Write tile data - struct tile *n64tile = (struct tile *) &src[cur_src_offset]; - struct tile hosttile; - - hosttile.type = n64tile->type; - hosttile.numvertices = n64tile->numvertices; - hosttile.flags = srctodst16(n64tile->flags); - hosttile.floortype = srctodst16(n64tile->floortype); - hosttile.xmin = n64tile->xmin; - hosttile.ymin = n64tile->ymin; - hosttile.zmin = n64tile->zmin; - hosttile.xmax = n64tile->xmax; - hosttile.ymax = n64tile->ymax; - hosttile.zmax = n64tile->zmax; - hosttile.floorcol = srctodst16(n64tile->floorcol); - - memcpy(&dst[cur_dst_offset], &hosttile, sizeof(struct tile)); - - cur_dst_offset += sizeof(struct tile); - cur_src_offset += sizeof(struct tile); - - // Write tile vertices - for (int i = 0; i < hosttile.numvertices; i++) { - *(s16 *) &dst[cur_dst_offset + 0] = srctodst16(*(s16 *) &src[cur_src_offset + 0]); - *(s16 *) &dst[cur_dst_offset + 2] = srctodst16(*(s16 *) &src[cur_src_offset + 2]); - *(s16 *) &dst[cur_dst_offset + 4] = srctodst16(*(s16 *) &src[cur_src_offset + 4]); - cur_dst_offset += 6; - cur_src_offset += 6; - } - } - - return ALIGN16(cur_dst_offset); -} - -u8 *preprocessTilesFile(u8 *data, u32 size, u32 *outSize) -{ - u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_TILES); - u8 *dst = sysMemZeroAlloc(newSizeEstimated); - - u32 newSize = convert_tiles(dst, data, size); - - if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a tiles file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); - } - - memcpy(data, dst, newSize); - sysMemFree(dst); - - *outSize = newSize; - - return 0; -} diff --git a/port/pdextract/ext_fonts.c b/port/pdextract/ext_fonts.c deleted file mode 100644 index b2f9ab1b8..000000000 --- a/port/pdextract/ext_fonts.c +++ /dev/null @@ -1,122 +0,0 @@ -#include -#include -#include -#include -#include -#include "common.h" -#include "system.h" - -struct n64fontchar { - u8 index; - s8 baseline; - u8 height; - u8 width; - s32 kerningindex; - u32 pixeldata; -}; - -struct hostfontchar { - u8 index; - s8 baseline; - u8 height; - u8 width; - s32 kerningindex; - uintptr_t pixeldata; -}; - -struct n64fontcharjpn { - u16 index; - s8 baseline; - u8 height; - u8 width; - s16 kerningindex; - u32 pixeldata; -}; - -struct hostfontcharjpn { - u16 index; - s8 baseline; - u8 height; - u8 width; - s16 kerningindex; - uintptr_t pixeldata; -}; - -struct fontdef { - const char *name; - u32 offsets[3]; - int pal_extra_chars; -}; - -u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) -{ - int num_chars = 94; -#if VERSION == VERSION_PAL_FINAL - // PAL has more characters in these fonts - extern u8* _fonthandelgothicsmSegmentRomStart; - extern u8* _fonthandelgothicxsSegmentRomStart; - extern u8* _fonthandelgothicmdSegmentRomStart; - if (src == _fonthandelgothicsmSegmentRomStart - || src == _fonthandelgothicxsSegmentRomStart - || src == _fonthandelgothicmdSegmentRomStart) { - numchars = 135; - } -#endif - - size_t dstlen = srclen - (num_chars * sizeof(struct n64fontchar)) + (num_chars * sizeof(struct hostfontchar)) + 0x20; - u8* dst = sysMemZeroAlloc(dstlen); - - // Kerning table - s32 *src_kerning_table = (s32 *)src; - s32 *dst_kerning_table = (s32 *)dst; - - for (int i = 0; i < 13 * 13; i++) { - dst_kerning_table[i] = srctodst32(src_kerning_table[i]); - } - - u32 src_offset = ALIGN(13 * 13 * 4, sizeof(u32)); - u32 dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); - - // Character table -#if VERSION == VERSION_JPN_FINAL - struct n64fontcharjpn *src_char_table = (struct n64fontcharjpn *) &src[src_offset]; - struct hostfontcharjpn *dst_char_table = (struct hostfontcharjpn *) &dst[dst_offset]; - u32 diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); - - for (int i = 0; i < num_chars; i++) { - dst_char_table[i].index = srctodst16(src_char_table[i].index); - dst_char_table[i].baseline = src_char_table[i].baseline; - dst_char_table[i].height = src_char_table[i].height; - dst_char_table[i].width = src_char_table[i].width; - dst_char_table[i].kerningindex = srctodst16(src_char_table[i].kerningindex); - dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? srctodst32(src_char_table[i].pixeldata) + diff : 0; - } - - src_offset += num_chars * sizeof(struct n64fontcharjpn); - dst_offset += num_chars * sizeof(struct hostfontcharjpn); -#else - struct n64fontchar *src_char_table = (struct n64fontchar *) &src[src_offset]; - struct hostfontchar *dst_char_table = (struct hostfontchar *) &dst[dst_offset]; - u32 diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); - - for (int i = 0; i < num_chars; i++) { - dst_char_table[i].index = src_char_table[i].index; - dst_char_table[i].baseline = src_char_table[i].baseline; - dst_char_table[i].height = src_char_table[i].height; - dst_char_table[i].width = src_char_table[i].width; - dst_char_table[i].kerningindex = srctodst32(src_char_table[i].kerningindex); - dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? srctodst32(src_char_table[i].pixeldata) + diff : 0; - } - - src_offset += num_chars * sizeof(struct n64fontchar); - dst_offset += num_chars * sizeof(struct hostfontchar); -#endif - - // Pixel data - u32 len = srclen - src_offset; - memcpy(&dst[dst_offset], &src[src_offset], len); - - if (outSize) *outSize = ALIGN16(dst_offset + len); - - return dst; -} diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c deleted file mode 100644 index ad2f6ba6f..000000000 --- a/port/pdextract/ext_setups.c +++ /dev/null @@ -1,1202 +0,0 @@ -#include -#include -#include - -#include "types.h" - -#include "assert.h" - -#include "common.h" -#include "setups_decl.h" - -#include "romdata.h" -#include "system.h" - - -static inline void convF32(f32 *dst, f32 src) { *(u32*)dst = srctoh32(*(u32*)&src); } -static inline void convU32(u32 *dst, u32 src) { *dst = srctoh32(src); } -static inline void convS32(s32 *dst, s32 src) { *dst = srctoh32(src); } -static inline void convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } -static inline void convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } -static inline void cpyByte(u8 *dst, u8 src) { *dst = src; } -static inline void convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } -static u32 convUnk(void* x, u32 y) { __debugbreak(); } - -#define PD_CONV_VAL(dst, src) _Generic((dst), \ - f32: convF32, \ - u32: convU32, \ - s32: convS32, \ - u16: convU16, \ - s16: convS16, \ - u8: cpyByte, \ - s8: cpyByte, \ - struct coord: convCoord, \ - default: convUnk \ -)(&dst, src) - -#define PD_CONV_ARRAY(dst, src) { for (int i = 0; i < ARRAYCOUNT(dst); i++) PD_CONV_VAL(dst[i], src[i]); } -#define PD_CONV_ARRAY2D(dst, src) { \ - for (int i = 0; i < ARRAYCOUNT(dst); i++) \ - for (int j = 0; j < ARRAYCOUNT(dst); j++) PD_CONV_VAL(dst[i][j], src[i][j]); \ -} - -#define PD_CONV_PTR(dst, src) dst = srctoh32(src) - -u32 obj_size(struct n64_defaultobj *obj) -{ - switch (obj->type) { - case OBJTYPE_CHR: return sizeof(struct n64_packedchr) / sizeof(u32); - case OBJTYPE_DOOR: return sizeof(struct n64_doorobj) / sizeof(u32); - case OBJTYPE_DOORSCALE: return sizeof(struct n64_doorscaleobj) / sizeof(u32); - case OBJTYPE_BASIC: return sizeof(struct n64_defaultobj) / sizeof(u32); - case OBJTYPE_DEBRIS: return sizeof(struct n64_debrisobj) / sizeof(u32); - case OBJTYPE_GLASS: return sizeof(struct n64_glassobj) / sizeof(u32); - case OBJTYPE_TINTEDGLASS: return sizeof(struct n64_tintedglassobj) / sizeof(u32); - case OBJTYPE_SAFE: return sizeof(struct n64_safeobj) / sizeof(u32); - case OBJTYPE_GASBOTTLE: return sizeof(struct gasbottleobj) / sizeof(u32); - case OBJTYPE_KEY: return sizeof(struct n64_keyobj) / sizeof(u32); - case OBJTYPE_ALARM: return sizeof(struct n64_alarmobj) / sizeof(u32); - case OBJTYPE_CCTV: return sizeof(struct n64_cctvobj) / sizeof(u32); - case OBJTYPE_AMMOCRATE: return sizeof(struct n64_ammocrateobj) / sizeof(u32); - case OBJTYPE_WEAPON: return sizeof(struct n64_weaponobj) / sizeof(u32); - case OBJTYPE_SINGLEMONITOR: return sizeof(struct n64_singlemonitorobj) / sizeof(u32); - case OBJTYPE_MULTIMONITOR: return sizeof(struct n64_multimonitorobj) / sizeof(u32); - case OBJTYPE_HANGINGMONITORS: return sizeof(struct n64_hangingmonitorsobj) / sizeof(u32); - case OBJTYPE_AUTOGUN: return sizeof(struct n64_autogunobj) / sizeof(u32); - case OBJTYPE_LINKGUNS: return sizeof(struct linkgunsobj) / sizeof(u32); - case OBJTYPE_HAT: return sizeof(struct n64_hatobj) / sizeof(u32); - case OBJTYPE_GRENADEPROB: return sizeof(struct grenadeprobobj) / sizeof(u32); - case OBJTYPE_LINKLIFTDOOR: return sizeof(struct n64_linkliftdoorobj) / sizeof(u32); - case OBJTYPE_SAFEITEM: return sizeof(struct n64_safeitemobj) / sizeof(u32); - case OBJTYPE_MULTIAMMOCRATE: return sizeof(struct n64_multiammocrateobj) / sizeof(u32); - case OBJTYPE_SHIELD: return sizeof(struct n64_shieldobj) / sizeof(u32); - case OBJTYPE_TAG: return sizeof(struct n64_tag) / sizeof(u32); - case OBJTYPE_RENAMEOBJ: return sizeof(struct n64_textoverride) / sizeof(u32); - case OBJTYPE_BEGINOBJECTIVE: return sizeof(struct n64_objective) / sizeof(u32); - case OBJTYPE_ENDOBJECTIVE: return 1; - case OBJECTIVETYPE_DESTROYOBJ: return 2; - case OBJECTIVETYPE_COMPFLAGS: return 2; - case OBJECTIVETYPE_FAILFLAGS: return 2; - case OBJECTIVETYPE_COLLECTOBJ: return 2; - case OBJECTIVETYPE_THROWOBJ: return 2; - case OBJECTIVETYPE_HOLOGRAPH: return sizeof(struct n64_criteria_holograph) / sizeof(u32); - case OBJECTIVETYPE_1F: return 1; - case OBJECTIVETYPE_ENTERROOM: return sizeof(struct n64_criteria_roomentered) / sizeof(u32); - case OBJECTIVETYPE_THROWINROOM: return sizeof(struct n64_criteria_throwinroom) / sizeof(u32); - case OBJTYPE_22: return 1; - case OBJTYPE_BRIEFING: return sizeof(struct n64_briefingobj) / sizeof(u32); - case OBJTYPE_PADLOCKEDDOOR: return sizeof(struct n64_padlockeddoorobj) / sizeof(u32); - case OBJTYPE_TRUCK: return sizeof(struct n64_truckobj) / sizeof(u32); - case OBJTYPE_HELI: return sizeof(struct n64_heliobj) / sizeof(u32); - case OBJTYPE_TANK: return 32; - case OBJTYPE_CAMERAPOS: return sizeof(struct n64_cameraposobj) / sizeof(u32); - case OBJTYPE_LIFT: return sizeof(struct n64_liftobj) / sizeof(u32); - case OBJTYPE_CONDITIONALSCENERY: return sizeof(struct n64_linksceneryobj) / sizeof(u32); - case OBJTYPE_BLOCKEDPATH: return sizeof(struct n64_blockedpathobj) / sizeof(u32); - case OBJTYPE_HOVERBIKE: return sizeof(struct n64_hoverbikeobj) / sizeof(u32); - case OBJTYPE_HOVERPROP: return sizeof(struct n64_hoverpropobj) / sizeof(u32); - case OBJTYPE_FAN: return sizeof(struct n64_fanobj) / sizeof(u32); - case OBJTYPE_HOVERCAR: return sizeof(struct n64_hovercarobj) / sizeof(u32); - case OBJTYPE_CHOPPER: return sizeof(struct n64_chopperobj) / sizeof(u32); - case OBJTYPE_PADEFFECT: return sizeof(struct padeffectobj) / sizeof(u32); - case OBJTYPE_MINE: return sizeof(struct n64_weaponobj) / sizeof(u32); - case OBJTYPE_ESCASTEP: return sizeof(struct n64_escalatorobj) / sizeof(u32); - } - - return 1; -} - - -void conv_tvscreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) -{ - PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist); - PD_CONV_VAL(dstobj->offset, srcobj->offset); - PD_CONV_VAL(dstobj->pause60, srcobj->pause60); - PD_CONV_PTR(dstobj->tconfig, srcobj->ptr_tconfig); - PD_CONV_VAL(dstobj->rot, srcobj->rot); - PD_CONV_VAL(dstobj->xscale, srcobj->xscale); - PD_CONV_VAL(dstobj->xscalefrac, srcobj->xscalefrac); - PD_CONV_VAL(dstobj->xscaleinc, srcobj->xscaleinc); - PD_CONV_VAL(dstobj->xscaleold, srcobj->xscaleold); - PD_CONV_VAL(dstobj->xscalenew, srcobj->xscalenew); - PD_CONV_VAL(dstobj->yscale, srcobj->yscale); - PD_CONV_VAL(dstobj->yscalefrac, srcobj->yscalefrac); - PD_CONV_VAL(dstobj->yscaleinc, srcobj->yscaleinc); - PD_CONV_VAL(dstobj->yscaleold, srcobj->yscaleold); - PD_CONV_VAL(dstobj->yscalenew, srcobj->yscalenew); - PD_CONV_VAL(dstobj->xmid, srcobj->xmid); - PD_CONV_VAL(dstobj->xmidfrac, srcobj->xmidfrac); - PD_CONV_VAL(dstobj->xmidinc, srcobj->xmidinc); - PD_CONV_VAL(dstobj->xmidold, srcobj->xmidold); - PD_CONV_VAL(dstobj->xmidnew, srcobj->xmidnew); - PD_CONV_VAL(dstobj->ymid, srcobj->ymid); - PD_CONV_VAL(dstobj->ymidfrac, srcobj->ymidfrac); - PD_CONV_VAL(dstobj->ymidinc, srcobj->ymidinc); - PD_CONV_VAL(dstobj->ymidold, srcobj->ymidold); - PD_CONV_VAL(dstobj->ymidnew, srcobj->ymidnew); - PD_CONV_VAL(dstobj->red, srcobj->red); - PD_CONV_VAL(dstobj->redold, srcobj->redold); - PD_CONV_VAL(dstobj->rednew, srcobj->rednew); - PD_CONV_VAL(dstobj->green, srcobj->green); - PD_CONV_VAL(dstobj->greenold, srcobj->greenold); - PD_CONV_VAL(dstobj->greennew, srcobj->greennew); - PD_CONV_VAL(dstobj->blue, srcobj->blue); - PD_CONV_VAL(dstobj->blueold, srcobj->blueold); - PD_CONV_VAL(dstobj->bluenew, srcobj->bluenew); - PD_CONV_VAL(dstobj->alpha, srcobj->alpha); - PD_CONV_VAL(dstobj->alphaold, srcobj->alphaold); - PD_CONV_VAL(dstobj->alphanew, srcobj->alphanew); - PD_CONV_VAL(dstobj->colfrac, srcobj->colfrac); - PD_CONV_VAL(dstobj->colinc, srcobj->colinc); -} - -void conv_default_obj_hdr(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) -{ - PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); - - /* 'header' is like this inside a u32: - u16 unk00_1, - u8 unk00_2, - u8 type, - */ - u16 *dst_unk00_1 = (u16*)&dstobj->extrascale; - u8 *dst_unk00_2 = (u8*)(dst_unk00_1 + 1); - - u16 *src_unk00_1 = (u16*)&srcobj->extrascale; - u8 *src_unk00_2 = (u8*)(src_unk00_1 + 1); - - *dst_unk00_1 = srctoh16(*src_unk00_1); - dst_unk00_2[0] = src_unk00_2[0]; - dst_unk00_2[1] = src_unk00_2[1]; -} - -void conv_default_obj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) -{ - PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); - PD_CONV_VAL(dstobj->hidden2, srcobj->hidden2); - PD_CONV_VAL(dstobj->type, srcobj->type); - PD_CONV_VAL(dstobj->modelnum, srcobj->modelnum); - PD_CONV_VAL(dstobj->pad, srcobj->pad); - PD_CONV_VAL(dstobj->flags, srcobj->flags); - PD_CONV_VAL(dstobj->flags2, srcobj->flags2); - PD_CONV_VAL(dstobj->flags3, srcobj->flags3); - PD_CONV_PTR(dstobj->prop, srcobj->ptr_prop); - PD_CONV_PTR(dstobj->model, srcobj->ptr_model); - PD_CONV_ARRAY2D(dstobj->realrot, srcobj->realrot); - PD_CONV_VAL(dstobj->hidden, srcobj->hidden); - PD_CONV_PTR(dstobj->unkgeo, srcobj->ptr_unkgeo); - PD_CONV_PTR(dstobj->embedment, srcobj->ptr_embedment); - PD_CONV_VAL(dstobj->damage, srcobj->damage); - PD_CONV_VAL(dstobj->maxdamage, srcobj->maxdamage); - PD_CONV_ARRAY(dstobj->shadecol, srcobj->shadecol); - PD_CONV_ARRAY(dstobj->nextcol, srcobj->nextcol); - PD_CONV_VAL(dstobj->floorcol, srcobj->floorcol); - PD_CONV_VAL(dstobj->geocount, srcobj->geocount); -} - -u32 convert_props(u8* dst, u8* src) -{ - u8* start = dst; - struct n64_defaultobj* cmd = (struct n64_defaultobj*)src; - - int i = 0; - u8 type = cmd->type; - - while (type != OBJTYPE_END) { - //sysLogPrintf(LOG_NOTE, "#%03d obj 0x%02x (%s)", ++i, type, objName(cmd)); - switch (type) { - case OBJTYPE_DOOR: - { - struct n64_doorobj* srcobj = (struct n64_doorobj*)cmd; - struct doorobj* dstobj = (struct doorobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->maxfrac, srcobj->maxfrac); - PD_CONV_VAL(dstobj->perimfrac, srcobj->perimfrac); - PD_CONV_VAL(dstobj->accel, srcobj->accel); - PD_CONV_VAL(dstobj->decel, srcobj->decel); - PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); - PD_CONV_VAL(dstobj->doorflags, srcobj->doorflags); - PD_CONV_VAL(dstobj->doortype, srcobj->doortype); - PD_CONV_VAL(dstobj->keyflags, srcobj->keyflags); - PD_CONV_VAL(dstobj->autoclosetime, srcobj->autoclosetime); - PD_CONV_VAL(dstobj->frac, srcobj->frac); - PD_CONV_VAL(dstobj->fracspeed, srcobj->fracspeed); - PD_CONV_VAL(dstobj->mode, srcobj->mode); - PD_CONV_VAL(dstobj->glasshits, srcobj->glasshits); - PD_CONV_VAL(dstobj->fadealpha, srcobj->fadealpha); - PD_CONV_VAL(dstobj->xludist, srcobj->xludist); - PD_CONV_VAL(dstobj->opadist, srcobj->opadist); - PD_CONV_VAL(dstobj->startpos, srcobj->startpos); - PD_CONV_ARRAY2D(dstobj->mtx98, srcobj->mtx98); - PD_CONV_PTR(dstobj->sibling, srcobj->ptr_sibling); - PD_CONV_VAL(dstobj->lastopen60, srcobj->lastopen60); - PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); - PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); - PD_CONV_VAL(dstobj->fadetime60, srcobj->fadetime60); - PD_CONV_VAL(dstobj->lastcalc60, srcobj->lastcalc60); - PD_CONV_VAL(dstobj->laserfade, srcobj->laserfade); - PD_CONV_ARRAY(dstobj->unusedmaybe, srcobj->unusedmaybe); - PD_CONV_ARRAY(dstobj->shadeinfo1, srcobj->shadeinfo1); - PD_CONV_ARRAY(dstobj->shadeinfo2, srcobj->shadeinfo2); - - PD_CONV_VAL(dstobj->actual1, srcobj->actual1); - PD_CONV_VAL(dstobj->actual2, srcobj->actual2); - PD_CONV_VAL(dstobj->extra1, srcobj->extra1); - PD_CONV_VAL(dstobj->extra2, srcobj->extra2); - - dst += sizeof(struct doorobj); - break; - } - case OBJTYPE_DOORSCALE: - { - struct n64_doorscaleobj* srcobj = (struct n64_doorscaleobj*)cmd; - struct doorscaleobj* dstobj = (struct doorscaleobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->scale, srcobj->scale); - - dst += sizeof(struct doorscaleobj); - break; - } - case OBJTYPE_BASIC: - case OBJTYPE_HANGINGMONITORS: - case OBJTYPE_DEBRIS: - case OBJTYPE_HAT: - case OBJTYPE_ALARM: - { - struct n64_defaultobj* srcobj = (struct n64_defaultobj*)cmd; - struct defaultobj* dstobj = (struct defaultobj*)dst; - - conv_default_obj(dstobj, cmd); - - dst += sizeof(struct defaultobj); - break; - } - case OBJTYPE_KEY: - { - struct n64_keyobj* srcobj = (struct n64_keyobj*)cmd; - struct keyobj* dstobj = (struct keyobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - PD_CONV_VAL(dstobj->keyflags, srcobj->keyflags); - - dst += sizeof(struct keyobj); - src += sizeof(struct n64_keyobj); - break; - } - case OBJTYPE_CCTV: - { - struct n64_cctvobj* srcobj = (struct n64_cctvobj*)cmd; - struct cctvobj* dstobj = (struct cctvobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->lookatpadnum, srcobj->lookatpadnum); - PD_CONV_VAL(dstobj->toleft, srcobj->toleft); - PD_CONV_VAL(dstobj->yzero, srcobj->yzero); - PD_CONV_VAL(dstobj->yrot, srcobj->yrot); - PD_CONV_VAL(dstobj->yleft, srcobj->yleft); - PD_CONV_VAL(dstobj->yright, srcobj->yright); - PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); - PD_CONV_VAL(dstobj->ymaxspeed, srcobj->ymaxspeed); - PD_CONV_VAL(dstobj->seebondtime60, srcobj->seebondtime60); - PD_CONV_VAL(dstobj->maxdist, srcobj->maxdist); - PD_CONV_VAL(dstobj->xzero, srcobj->xzero); - - dst += sizeof(struct cctvobj); - break; - } - case OBJTYPE_AMMOCRATE: - { - struct n64_ammocrateobj* srcobj = (struct n64_ammocrateobj*)cmd; - struct ammocrateobj* dstobj = (struct ammocrateobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - PD_CONV_VAL(dstobj->ammotype, srcobj->ammotype); - - dst += sizeof(struct ammocrateobj); - break; - } - case OBJTYPE_WEAPON: - case OBJTYPE_MINE: - { - struct n64_weaponobj* srcobj = (struct n64_weaponobj*)cmd; - struct weaponobj* dstobj = (struct weaponobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->weaponnum, srcobj->weaponnum); - PD_CONV_VAL(dstobj->unk5d, srcobj->unk5d); - PD_CONV_VAL(dstobj->unk5e, srcobj->unk5e); - PD_CONV_VAL(dstobj->gunfunc, srcobj->gunfunc); - - PD_CONV_VAL(dstobj->fadeouttimer60, srcobj->fadeouttimer60); - PD_CONV_VAL(dstobj->dualweaponnum, srcobj->dualweaponnum); - - PD_CONV_VAL(dstobj->team, srcobj->team); - - PD_CONV_PTR(dstobj->dualweapon, srcobj->ptr_dualweapon); - - dst += sizeof(struct weaponobj); - break; - } - case OBJTYPE_CHR: - { - struct n64_packedchr* srcobj = (struct n64_packedchr*)cmd; - struct packedchr* dstobj = (struct packedchr*)dst; - - PD_CONV_VAL(dstobj->chrindex, srcobj->chrindex); - PD_CONV_VAL(dstobj->unk02, srcobj->unk02); - PD_CONV_VAL(dstobj->typenum, srcobj->typenum); - PD_CONV_VAL(dstobj->spawnflags, srcobj->spawnflags); - PD_CONV_VAL(dstobj->chrnum, srcobj->chrnum); - PD_CONV_VAL(dstobj->padnum, srcobj->padnum); - PD_CONV_VAL(dstobj->bodynum, srcobj->bodynum); - PD_CONV_VAL(dstobj->headnum, srcobj->headnum); - PD_CONV_VAL(dstobj->ailistnum, srcobj->ailistnum); - PD_CONV_VAL(dstobj->padpreset, srcobj->padpreset); - PD_CONV_VAL(dstobj->chrpreset, srcobj->chrpreset); - PD_CONV_VAL(dstobj->hearscale, srcobj->hearscale); - PD_CONV_VAL(dstobj->viewdist, srcobj->viewdist); - PD_CONV_VAL(dstobj->flags, srcobj->flags); - PD_CONV_VAL(dstobj->flags2, srcobj->flags2); - PD_CONV_VAL(dstobj->team, srcobj->team); - PD_CONV_VAL(dstobj->squadron, srcobj->squadron); - PD_CONV_VAL(dstobj->chair, srcobj->chair); - PD_CONV_VAL(dstobj->convtalk, srcobj->convtalk); - PD_CONV_VAL(dstobj->tude, srcobj->tude); - PD_CONV_VAL(dstobj->naturalanim, srcobj->naturalanim); - PD_CONV_VAL(dstobj->yvisang, srcobj->yvisang); - PD_CONV_VAL(dstobj->teamscandist, srcobj->teamscandist); - - dst += sizeof(struct packedchr); - break; - } - case OBJTYPE_SINGLEMONITOR: - { - struct n64_singlemonitorobj* srcobj = (struct n64_singlemonitorobj*)cmd; - struct singlemonitorobj* dstobj = (struct singlemonitorobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - conv_tvscreen(&dstobj->screen, &srcobj->screen); - - PD_CONV_VAL(dstobj->owneroffset, srcobj->owneroffset); - PD_CONV_VAL(dstobj->ownerpart, srcobj->ownerpart); - PD_CONV_VAL(dstobj->imagenum, srcobj->imagenum); - - dst += sizeof(struct singlemonitorobj); - break; - } - case OBJTYPE_MULTIMONITOR: - { - struct n64_multimonitorobj* srcobj = (struct n64_multimonitorobj*)cmd; - struct multimonitorobj* dstobj = (struct multimonitorobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - for (size_t i = 0; i < 4; i++) - conv_tvscreen(&dstobj->screens[i], &srcobj->screens[i]); - - PD_CONV_ARRAY(dstobj->imagenums, srcobj->imagenums); - dst += sizeof(struct multimonitorobj); - break; - } - case OBJTYPE_AUTOGUN: - { - struct n64_autogunobj* srcobj = (struct n64_autogunobj*)cmd; - struct autogunobj* dstobj = (struct autogunobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->targetpad, srcobj->targetpad); - PD_CONV_VAL(dstobj->firing, srcobj->firing); - PD_CONV_VAL(dstobj->firecount, srcobj->firecount); - PD_CONV_VAL(dstobj->yzero, srcobj->yzero); - PD_CONV_VAL(dstobj->ymaxleft, srcobj->ymaxleft); - PD_CONV_VAL(dstobj->ymaxright, srcobj->ymaxright); - PD_CONV_VAL(dstobj->yrot, srcobj->yrot); - PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); - PD_CONV_VAL(dstobj->xzero, srcobj->xzero); - PD_CONV_VAL(dstobj->xrot, srcobj->xrot); - PD_CONV_VAL(dstobj->xspeed, srcobj->xspeed); - PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); - PD_CONV_VAL(dstobj->aimdist, srcobj->aimdist); - PD_CONV_VAL(dstobj->barrelspeed, srcobj->barrelspeed); - PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); - PD_CONV_VAL(dstobj->lastseebond60, srcobj->lastseebond60); - PD_CONV_VAL(dstobj->lastaimbond60, srcobj->lastaimbond60); - PD_CONV_VAL(dstobj->allowsoundframe, srcobj->allowsoundframe); - PD_CONV_PTR(dstobj->beam, srcobj->ptr_beam); - PD_CONV_VAL(dstobj->shotbondsum, srcobj->shotbondsum); - PD_CONV_PTR(dstobj->target, srcobj->ptr_target); - PD_CONV_VAL(dstobj->targetteam, srcobj->targetteam); - PD_CONV_VAL(dstobj->ammoquantity, srcobj->ammoquantity); - PD_CONV_VAL(dstobj->nextchrtest, srcobj->nextchrtest); - - dst += sizeof(struct autogunobj); - break; - } - case OBJTYPE_LINKGUNS: - { - struct n64_linkgunsobj* srcobj = (struct n64_linkgunsobj*)cmd; - struct linkgunsobj* dstobj = (struct linkgunsobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->offset1, srcobj->offset1); - PD_CONV_VAL(dstobj->offset2, srcobj->offset2); - - dst += sizeof(struct linkgunsobj); - break; - } - case OBJTYPE_GRENADEPROB: - { - struct n64_grenadeprobobj* srcobj = (struct n64_grenadeprobobj*)cmd; - struct grenadeprobobj* dstobj = (struct grenadeprobobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->chrnum, srcobj->chrnum); - PD_CONV_VAL(dstobj->probability, srcobj->probability); - - dst += sizeof(struct grenadeprobobj); - break; - } - case OBJTYPE_LINKLIFTDOOR: - { - struct n64_linkliftdoorobj* srcobj = (struct n64_linkliftdoorobj*)cmd; - struct linkliftdoorobj* dstobj = (struct linkliftdoorobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->lift, srcobj->ptr_lift); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - PD_CONV_VAL(dstobj->stopnum, srcobj->stopnum); - - dst += sizeof(struct linkliftdoorobj); - break; - } - case OBJTYPE_MULTIAMMOCRATE: - { - struct n64_multiammocrateobj* srcobj = (struct n64_multiammocrateobj*)cmd; - struct multiammocrateobj* dstobj = (struct multiammocrateobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - for (size_t i = 0; i < 19; i++) { - PD_CONV_VAL(dstobj->slots[i].modelnum, srcobj->slots[i].modelnum); - PD_CONV_VAL(dstobj->slots[i].quantity, srcobj->slots[i].quantity); - } - - dst += sizeof(struct multiammocrateobj); - break; - } - case OBJTYPE_SHIELD: - { - struct n64_shieldobj* srcobj = (struct n64_shieldobj*)cmd; - struct shieldobj* dstobj = (struct shieldobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->initialamount, srcobj->initialamount); - PD_CONV_VAL(dstobj->amount, srcobj->amount); - PD_CONV_VAL(dstobj->unk64, srcobj->unk64); - - dst += sizeof(struct shieldobj); - break; - } - case OBJTYPE_TAG: - { - struct n64_tag* srcobj = (struct n64_tag*)cmd; - struct tag* dstobj = (struct tag*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->tagnum, srcobj->tagnum); - PD_CONV_VAL(dstobj->cmdoffset, srcobj->cmdoffset); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); - - dst += sizeof(struct tag); - break; - } - case OBJTYPE_BEGINOBJECTIVE: - { - struct n64_objective* srcobj = (struct n64_objective*)cmd; - struct objective* dstobj = (struct objective*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->index, srcobj->index); - PD_CONV_VAL(dstobj->text, srcobj->text); - PD_CONV_VAL(dstobj->unk0c, srcobj->unk0c); - PD_CONV_VAL(dstobj->flags, srcobj->flags); - PD_CONV_VAL(dstobj->difficulties, srcobj->difficulties); - - dst += sizeof(struct objective); - break; - } - case OBJTYPE_ENDOBJECTIVE: - case OBJECTIVETYPE_1F: - case OBJTYPE_22: - case OBJTYPE_GASBOTTLE: - case OBJTYPE_29: - case OBJTYPE_SAFE: - { - struct n64_stdobjective* srcobj = (struct n64_stdobjective*)cmd; - struct n64_stdobjective* dstobj = (struct n64_stdobjective*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - - dst += sizeof(struct n64_stdobjective); - break; - } - case OBJECTIVETYPE_DESTROYOBJ: - case OBJECTIVETYPE_COMPFLAGS: - case OBJECTIVETYPE_FAILFLAGS: - case OBJECTIVETYPE_COLLECTOBJ: - case OBJECTIVETYPE_THROWOBJ: - { - struct n64_objectivecmd* srcobj = (struct n64_objectivecmd*)cmd; - struct n64_objectivecmd* dstobj = (struct n64_objectivecmd*)dst; - - PD_CONV_ARRAY(dstobj->cmd0, srcobj->cmd0); - PD_CONV_VAL(dstobj->cmd1, srcobj->cmd1); - - dst += sizeof(struct n64_objectivecmd); - break; - } - case OBJECTIVETYPE_HOLOGRAPH: - { - struct n64_criteria_holograph* srcobj = (struct n64_criteria_holograph*)cmd; - struct criteria_holograph* dstobj = (struct criteria_holograph*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->obj, srcobj->obj); - PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - - dst += sizeof(struct criteria_holograph); - break; - } - case OBJECTIVETYPE_ENTERROOM: - { - struct n64_criteria_roomentered* srcobj = (struct n64_criteria_roomentered*)cmd; - struct criteria_roomentered* dstobj = (struct criteria_roomentered*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->pad, srcobj->pad); - PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - - dst += sizeof(struct criteria_roomentered); - break; - } - case OBJECTIVETYPE_THROWINROOM: - { - struct n64_criteria_throwinroom* srcobj = (struct n64_criteria_throwinroom*)cmd; - struct criteria_throwinroom* dstobj = (struct criteria_throwinroom*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->pad, srcobj->pad); - PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - - dst += sizeof(struct criteria_throwinroom); - break; - } - case OBJTYPE_BRIEFING: - { - struct n64_briefingobj* srcobj = (struct n64_briefingobj*)cmd; - struct briefingobj* dstobj = (struct briefingobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->type, srcobj->type); - PD_CONV_VAL(dstobj->text, srcobj->text); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - - dst += sizeof(struct briefingobj); - break; - } - case OBJTYPE_RENAMEOBJ: - { - struct n64_textoverride* srcobj = (struct n64_textoverride*)cmd; - struct textoverride* dstobj = (struct textoverride*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->objoffset, srcobj->objoffset); - PD_CONV_VAL(dstobj->weapon, srcobj->weapon); - PD_CONV_VAL(dstobj->obtaintext, srcobj->obtaintext); - PD_CONV_VAL(dstobj->ownertext, srcobj->ownertext); - PD_CONV_VAL(dstobj->inventorytext, srcobj->inventorytext); - PD_CONV_VAL(dstobj->inventory2text, srcobj->inventory2text); - PD_CONV_VAL(dstobj->pickuptext, srcobj->pickuptext); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); - - dst += sizeof(struct textoverride); - break; - } - case OBJTYPE_PADLOCKEDDOOR: - { - struct n64_padlockeddoorobj* srcobj = (struct n64_padlockeddoorobj*)cmd; - struct padlockeddoorobj* dstobj = (struct padlockeddoorobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->lock, srcobj->ptr_lock); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - - dst += sizeof(struct padlockeddoorobj); - break; - } - case OBJTYPE_TRUCK: - { - struct n64_truckobj* srcobj = (struct n64_truckobj*)cmd; - struct truckobj* dstobj = (struct truckobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); - PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); - PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); - PD_CONV_VAL(dstobj->speed, srcobj->speed); - PD_CONV_VAL(dstobj->wheelxrot, srcobj->wheelxrot); - PD_CONV_VAL(dstobj->wheelyrot, srcobj->wheelyrot); - PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); - PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); - PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); - PD_CONV_VAL(dstobj->roty, srcobj->roty); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); - PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); - - dst += sizeof(struct truckobj); - break; - } - case OBJTYPE_HELI: - { - struct n64_heliobj* srcobj = (struct n64_heliobj*)cmd; - struct heliobj* dstobj = (struct heliobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); - PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); - PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); - PD_CONV_VAL(dstobj->rotoryrot, srcobj->rotoryrot); - PD_CONV_VAL(dstobj->rotoryspeed, srcobj->rotoryspeed); - PD_CONV_VAL(dstobj->rotoryspeedaim, srcobj->rotoryspeedaim); - PD_CONV_VAL(dstobj->rotoryspeedtime, srcobj->rotoryspeedtime); - PD_CONV_VAL(dstobj->speed, srcobj->speed); - PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); - PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); - PD_CONV_VAL(dstobj->yrot, srcobj->yrot); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); - PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); - - dst += sizeof(struct heliobj); - break; - } - case OBJTYPE_GLASS: - { - struct n64_glassobj* srcobj = (struct n64_glassobj*)cmd; - struct glassobj* dstobj = (struct glassobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); - - dst += sizeof(struct glassobj); - break; - } - case OBJTYPE_SAFEITEM: - { - struct n64_safeitemobj* srcobj = (struct n64_safeitemobj*)cmd; - struct safeitemobj* dstobj = (struct safeitemobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->item, srcobj->ptr_item); - PD_CONV_PTR(dstobj->safe, srcobj->ptr_safe); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - - dst += sizeof(struct safeitemobj); - break; - } - case OBJTYPE_TANK: - { - dst += sizeof(struct n64_tankobj); - break; - } - case OBJTYPE_CAMERAPOS: - { - struct n64_cameraposobj* srcobj = (struct n64_cameraposobj*)cmd; - struct cameraposobj* dstobj = (struct cameraposobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->x, srcobj->x); - PD_CONV_VAL(dstobj->y, srcobj->y); - PD_CONV_VAL(dstobj->z, srcobj->z); - PD_CONV_VAL(dstobj->theta, srcobj->theta); - PD_CONV_VAL(dstobj->verta, srcobj->verta); - PD_CONV_VAL(dstobj->pad, srcobj->pad); - - dst += sizeof(struct cameraposobj); - break; - } - case OBJTYPE_TINTEDGLASS: - { - struct n64_tintedglassobj* srcobj = (struct n64_tintedglassobj*)cmd; - struct tintedglassobj* dstobj = (struct tintedglassobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->xludist, srcobj->xludist); - PD_CONV_VAL(dstobj->opadist, srcobj->opadist); - PD_CONV_VAL(dstobj->opacity, srcobj->opacity); - PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); - PD_CONV_VAL(dstobj->unk64, srcobj->unk64); - - dst += sizeof(struct tintedglassobj); - break; - } - case OBJTYPE_LIFT: - { - struct n64_liftobj* srcobj = (struct n64_liftobj*)cmd; - struct liftobj* dstobj = (struct liftobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_ARRAY(dstobj->pads, srcobj->pads); - for (int k = 0; k < 4; k++) - PD_CONV_PTR(dstobj->doors[k], srcobj->ptr_doors[k]); - PD_CONV_VAL(dstobj->dist, srcobj->dist); - PD_CONV_VAL(dstobj->speed, srcobj->speed); - PD_CONV_VAL(dstobj->accel, srcobj->accel); - PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); - PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); - PD_CONV_VAL(dstobj->levelcur, srcobj->levelcur); - PD_CONV_VAL(dstobj->levelaim, srcobj->levelaim); - PD_CONV_VAL(dstobj->prevpos, srcobj->prevpos); - - dst += sizeof(struct liftobj); - break; - } - case OBJTYPE_CONDITIONALSCENERY: - { - struct n64_linksceneryobj* srcobj = (struct n64_linksceneryobj*)cmd; - struct linksceneryobj* dstobj = (struct linksceneryobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->trigger, srcobj->ptr_trigger); - PD_CONV_PTR(dstobj->unexp, srcobj->ptr_unexp); - PD_CONV_PTR(dstobj->exp, srcobj->ptr_exp); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - - dst += sizeof(struct linksceneryobj); - break; - } - case OBJTYPE_BLOCKEDPATH: - { - struct n64_blockedpathobj* srcobj = (struct n64_blockedpathobj*)cmd; - struct blockedpathobj* dstobj = (struct blockedpathobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->blocker, srcobj->ptr_blocker); - PD_CONV_VAL(dstobj->waypoint1, srcobj->waypoint1); - PD_CONV_VAL(dstobj->waypoint2, srcobj->waypoint2); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - - dst += sizeof(struct blockedpathobj); - break; - } - case OBJTYPE_HOVERBIKE: { - struct n64_hoverbikeobj* srcobj = (struct n64_hoverbikeobj*)cmd; - struct hoverbikeobj* dstobj = (struct hoverbikeobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->hov.type, srcobj->hov.type); - PD_CONV_VAL(dstobj->hov.flags, srcobj->hov.flags); - PD_CONV_VAL(dstobj->hov.bobycur, srcobj->hov.bobycur); - PD_CONV_VAL(dstobj->hov.bobytarget, srcobj->hov.bobytarget); - PD_CONV_VAL(dstobj->hov.bobyspeed, srcobj->hov.bobyspeed); - PD_CONV_VAL(dstobj->hov.yrot, srcobj->hov.yrot); - PD_CONV_VAL(dstobj->hov.bobpitchcur, srcobj->hov.bobpitchcur); - PD_CONV_VAL(dstobj->hov.bobpitchtarget, srcobj->hov.bobpitchtarget); - PD_CONV_VAL(dstobj->hov.bobpitchspeed, srcobj->hov.bobpitchspeed); - PD_CONV_VAL(dstobj->hov.bobrollcur, srcobj->hov.bobrollcur); - PD_CONV_VAL(dstobj->hov.bobrolltarget, srcobj->hov.bobrolltarget); - PD_CONV_VAL(dstobj->hov.bobrollspeed, srcobj->hov.bobrollspeed); - PD_CONV_VAL(dstobj->hov.groundpitch, srcobj->hov.groundpitch); - PD_CONV_VAL(dstobj->hov.y, srcobj->hov.y); - PD_CONV_VAL(dstobj->hov.ground, srcobj->hov.ground); - PD_CONV_VAL(dstobj->hov.prevframe60, srcobj->hov.prevframe60); - PD_CONV_VAL(dstobj->hov.prevgroundframe60, srcobj->hov.prevgroundframe60); - - PD_CONV_ARRAY(dstobj->speed, srcobj->speed); - PD_CONV_VAL(dstobj->exreal, srcobj->exreal); - PD_CONV_VAL(dstobj->ezreal, srcobj->ezreal); - PD_CONV_VAL(dstobj->ezreal2, srcobj->ezreal2); - PD_CONV_VAL(dstobj->leanspeed, srcobj->leanspeed); - PD_CONV_VAL(dstobj->leandiff, srcobj->leandiff); - PD_CONV_VAL(dstobj->maxspeedtime240, srcobj->maxspeedtime240); - PD_CONV_ARRAY(dstobj->prevpos, srcobj->prevpos); - PD_CONV_ARRAY(dstobj->rels, srcobj->rels); - PD_CONV_ARRAY(dstobj->speedabs, srcobj->speedabs); - PD_CONV_ARRAY(dstobj->speedrel, srcobj->speedrel); - - dst += sizeof(struct hoverbikeobj); - break; - } - case OBJTYPE_HOVERPROP: - { - struct n64_hoverpropobj* srcobj = (struct n64_hoverpropobj*)cmd; - struct hoverpropobj* dstobj = (struct hoverpropobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->hov.type, srcobj->hov.type); - PD_CONV_VAL(dstobj->hov.flags, srcobj->hov.flags); - PD_CONV_VAL(dstobj->hov.bobycur, srcobj->hov.bobycur); - PD_CONV_VAL(dstobj->hov.bobytarget, srcobj->hov.bobytarget); - PD_CONV_VAL(dstobj->hov.bobyspeed, srcobj->hov.bobyspeed); - PD_CONV_VAL(dstobj->hov.yrot, srcobj->hov.yrot); - PD_CONV_VAL(dstobj->hov.bobpitchcur, srcobj->hov.bobpitchcur); - PD_CONV_VAL(dstobj->hov.bobpitchtarget, srcobj->hov.bobpitchtarget); - PD_CONV_VAL(dstobj->hov.bobpitchspeed, srcobj->hov.bobpitchspeed); - PD_CONV_VAL(dstobj->hov.bobrollcur, srcobj->hov.bobrollcur); - PD_CONV_VAL(dstobj->hov.bobrolltarget, srcobj->hov.bobrolltarget); - PD_CONV_VAL(dstobj->hov.bobrollspeed, srcobj->hov.bobrollspeed); - PD_CONV_VAL(dstobj->hov.groundpitch, srcobj->hov.groundpitch); - PD_CONV_VAL(dstobj->hov.y, srcobj->hov.y); - PD_CONV_VAL(dstobj->hov.ground, srcobj->hov.ground); - PD_CONV_VAL(dstobj->hov.prevframe60, srcobj->hov.prevframe60); - PD_CONV_VAL(dstobj->hov.prevgroundframe60, srcobj->hov.prevgroundframe60); - - dst += sizeof(struct hoverpropobj); - break; - } - case OBJTYPE_FAN: - { - struct n64_fanobj* srcobj = (struct n64_fanobj*)cmd; - struct fanobj* dstobj = (struct fanobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->yrot, srcobj->yrot); - PD_CONV_VAL(dstobj->yrotprev, srcobj->yrotprev); - PD_CONV_VAL(dstobj->ymaxspeed, srcobj->ymaxspeed); - PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); - PD_CONV_VAL(dstobj->yaccel, srcobj->yaccel); - PD_CONV_VAL(dstobj->on, srcobj->on); - - dst += sizeof(struct fanobj); - break; - } - case OBJTYPE_HOVERCAR: - { - struct n64_hovercarobj* srcobj = (struct n64_hovercarobj*)cmd; - struct hovercarobj* dstobj = (struct hovercarobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); - PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); - PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); - PD_CONV_VAL(dstobj->speed, srcobj->speed); - PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); - PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); - PD_CONV_VAL(dstobj->turnyspeed60, srcobj->turnyspeed60); - PD_CONV_VAL(dstobj->turnxspeed60, srcobj->turnxspeed60); - PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); - PD_CONV_VAL(dstobj->roty, srcobj->roty); - PD_CONV_VAL(dstobj->rotx, srcobj->rotx); - PD_CONV_VAL(dstobj->rotz, srcobj->rotz); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); - PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); - PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_VAL(dstobj->dead, srcobj->dead); - PD_CONV_VAL(dstobj->deadtimer60, srcobj->deadtimer60); - PD_CONV_VAL(dstobj->sparkstimer60, srcobj->sparkstimer60); - - dst += sizeof(struct hovercarobj); - break; - } - case OBJTYPE_PADEFFECT: - { - struct padeffectobj* srcobj = (struct padeffectobj*)cmd; - struct padeffectobj* dstobj = (struct padeffectobj*)dst; - - conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); - PD_CONV_VAL(dstobj->effect, srcobj->effect); - PD_CONV_VAL(dstobj->pad, srcobj->pad); - - dst += sizeof(struct padeffectobj); - break; - } - case OBJTYPE_CHOPPER: - { - struct n64_chopperobj* srcobj = (struct n64_chopperobj*)cmd; - struct chopperobj* dstobj = (struct chopperobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); - PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); - PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); - PD_CONV_VAL(dstobj->speed, srcobj->speed); - PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); - PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); - PD_CONV_VAL(dstobj->turnyspeed60, srcobj->turnyspeed60); - PD_CONV_VAL(dstobj->turnxspeed60, srcobj->turnxspeed60); - PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); - PD_CONV_VAL(dstobj->roty, srcobj->roty); - PD_CONV_VAL(dstobj->rotx, srcobj->rotx); - PD_CONV_VAL(dstobj->rotz, srcobj->rotz); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); - PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); - PD_CONV_VAL(dstobj->weaponsarmed, srcobj->weaponsarmed); - PD_CONV_VAL(dstobj->ontarget, srcobj->ontarget); - PD_CONV_VAL(dstobj->target, srcobj->target); - PD_CONV_VAL(dstobj->attackmode, srcobj->attackmode); - PD_CONV_VAL(dstobj->cw, srcobj->cw); - PD_CONV_VAL(dstobj->vx, srcobj->vx); - PD_CONV_VAL(dstobj->vy, srcobj->vy); - PD_CONV_VAL(dstobj->vz, srcobj->vz); - PD_CONV_VAL(dstobj->power, srcobj->power); - PD_CONV_VAL(dstobj->otx, srcobj->otx); - PD_CONV_VAL(dstobj->oty, srcobj->oty); - PD_CONV_VAL(dstobj->otz, srcobj->otz); - PD_CONV_VAL(dstobj->bob, srcobj->bob); - PD_CONV_VAL(dstobj->bobstrength, srcobj->bobstrength); - PD_CONV_VAL(dstobj->targetvisible, srcobj->targetvisible); - PD_CONV_VAL(dstobj->timer60, srcobj->timer60); - PD_CONV_VAL(dstobj->patroltimer60, srcobj->patroltimer60); - PD_CONV_VAL(dstobj->gunturnyspeed60, srcobj->gunturnyspeed60); - PD_CONV_VAL(dstobj->gunturnxspeed60, srcobj->gunturnxspeed60); - PD_CONV_VAL(dstobj->gunroty, srcobj->gunroty); - PD_CONV_VAL(dstobj->gunrotx, srcobj->gunrotx); - PD_CONV_VAL(dstobj->barrelrotspeed, srcobj->barrelrotspeed); - PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); - PD_CONV_PTR(dstobj->fireslotthing, srcobj->ptr_fireslotthing); - PD_CONV_VAL(dstobj->dead, srcobj->dead); - - dst += sizeof(struct chopperobj); - break; - } - case OBJTYPE_ESCASTEP: - { - struct n64_escalatorobj* srcobj = (struct n64_escalatorobj*)cmd; - struct escalatorobj* dstobj = (struct escalatorobj*)dst; - - conv_default_obj(&dstobj->base, cmd); - - PD_CONV_VAL(dstobj->frame, srcobj->frame); - PD_CONV_VAL(dstobj->prevpos, srcobj->prevpos); - - dst += sizeof(struct escalatorobj); - break; - } - } - - cmd = (struct n64_defaultobj*)((u32*)cmd + obj_size(cmd)); - type = cmd->type; - } - - *(u32*)(dst) = htobe32(OBJTYPE_END); - dst += sizeof(u32); - - return (u32)(dst - start); -} - -static uintptr_t convert_intro(u8 *dst, u8 *src) -{ - u8 cmd_size[] = { - 3, // INTROCMD_SPAWN - 4, // INTROCMD_WEAPON - 4, // INTROCMD_AMMO - 8, // INTROCMD_3 - 2, // INTROCMD_4 - 2, // INTROCMD_OUTFIT - 10, // INTROCMD_6 - 3, // INTROCMD_WATCHTIME - 2, // INTROCMD_CREDITOFFSET - 3, // INTROCMD_CASE - 3, // INTROCMD_CASERESPAWN - 2, // INTROCMD_HILL - 1, // the INTROCMD_END constant itself - }; - - s32* dstintro = (s32*)dst; - s32* srcintro = (s32*)src; - - while (true) { - s32 cmd = dstintro[0] = srctodst32(srcintro[0]); - u8 size = cmd_size[*dstintro]; - for (int i = 1; i < size; i++) { - dstintro[i] = srctodst32(srcintro[i]); - } - - dstintro += size; - srcintro += size; - - if (cmd == INTROCMD_END) break; - } - - return (u32)((u8*)dstintro - dst); -} - -static u32 convert_paths(u8 *dst, u8 *src) -{ - struct n64_path* srcpath = (struct n64_path*)src; - struct path* dstpath = (struct path*)dst; - - while (true) { - PD_CONV_PTR(dstpath->pads, srcpath->ptr_pads); - PD_CONV_VAL(dstpath->id, srcpath->id); - PD_CONV_VAL(dstpath->flags, srcpath->flags); - PD_CONV_VAL(dstpath->len, srcpath->len); - - if (srcpath->ptr_pads == 0) break; - - dstpath++; - srcpath++; - } - - // extra pointer for the end marker - return (u32)((u8*)dstpath - dst + sizeof(uintptr_t)); -} - -static u32 convert_pads(struct path *dstpaths, u8 *dst, u8 *src, u32 dstpos) -{ - u32 start = dstpos; - s32 *dstpads = (s32*)&dst[dstpos]; - while (dstpaths->pads) { - s32 *pads = (s32*)&src[(uintptr_t)dstpaths->pads]; - dstpaths->pads = (s32*)dstpos; - - while (*pads) { - s32 p = srctoh32(*pads++); - *dstpads++ = p; - dstpos += sizeof(s32); - if (p == -1) break; - } - - dstpaths++; - } - - return dstpos - start; -} - -static u32 convert_ailists(u8* dst, u8* src) -{ - struct n64_ailist* srcailist = (struct n64_ailist*)src; - struct ailist* dstailist = (struct ailist*)dst; - - while (true) { - // at this point these fields are already converted, so we just assign - dstailist->list = srcailist->ptr_list; - dstailist->id = srcailist->id; - - - if (srcailist->ptr_list == 0) break; - - dstailist++; - srcailist++; - } - - return (u32)((u8*)dstailist - dst + sizeof(uintptr_t)); -} - -u32 chraiGetAilistLength(u8 *list); - -static u32 convert_lists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) -{ - reset_markers(); - struct n64_ailist *src_ailists = (struct n64_ailist*)&src[src_ofs]; - - // count the lists and pre-convert the fields - int nlists = 0; - for (struct n64_ailist *tmp = src_ailists; tmp->ptr_list; tmp++, nlists++) { - tmp->ptr_list = srctodst32(tmp->ptr_list); - tmp->id = srctodst32(tmp->id); - } - - for (struct n64_ailist *ailist = src_ailists; ailist->ptr_list; ailist++) { - // update the src list pointers here - uintptr_t src_ptr_list = (uintptr_t) ailist->ptr_list; - ailist->ptr_list = (u8*)dstpos; - - // multiple ailists can point to the same list, so we need to check if it was already copied - struct ptrmarker *marker = find_ptr_marker(src_ptr_list); - if (marker) { - ailist->ptr_list = marker->ptr_host; - continue; - } - - add_marker(src_ptr_list, dstpos); - - u8 *list = &src[src_ptr_list]; - u32 listsize = chraiGetAilistLength(list); - memcpy(dst + dstpos, list, listsize); - - // align to the next multiple of 4 - dstpos += ((listsize + 3) >> 2) << 2; - } - - return dstpos; -} - -static int convert_setup(u8 *dst, u8 *src, u32 srclen) -{ - struct n64_stagesetup *src_header = (struct n64_stagesetup*)src; - struct stagesetup *dst_header = (struct stagesetup*)dst; - - src_header->ptr_props = srctodst32(src_header->ptr_props); - src_header->ptr_intro = srctodst32(src_header->ptr_intro); - src_header->ptr_ailists = srctodst32(src_header->ptr_ailists); - src_header->ptr_paths = srctodst32(src_header->ptr_paths); - - u32 srcpos = sizeof(*src_header); - u32 dstpos = sizeof(*dst_header); - - srcpos = src_header->ptr_props; - dst_header->props = (u32*) dstpos; - dstpos += convert_props(&dst[dstpos], &src[srcpos]); - - srcpos = src_header->ptr_intro; - dst_header->intro = (s32*)dstpos; - dstpos += convert_intro(&dst[dstpos], &src[srcpos]); - - // write the lists bytecodes before the ailists entries - dstpos = convert_lists(dst, src, dstpos, src_header->ptr_ailists); - - srcpos = src_header->ptr_ailists; - dst_header->ailists = (struct ailist*)dstpos; - dstpos += convert_ailists(&dst[dstpos], &src[srcpos]); - - srcpos = src_header->ptr_paths; - dst_header->paths = (struct path*) dstpos; - dstpos += convert_paths(&dst[dstpos], &src[srcpos]); - - dstpos += convert_pads(&dst[(uintptr_t)dst_header->paths], dst, src, dstpos); - - return dstpos; -} - -u8 *preprocessSetupFile(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = romdataGetEstimatedFileSize(size, FT_SETUP); - u8 *dst = sysMemZeroAlloc(newSizeEstimated); - - u32 newSize = convert_setup(dst, data, size); - - if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a model file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); - } - - memcpy(data, dst, newSize); - sysMemFree(dst); - - *outSize = newSize; - - return 0; -} diff --git a/port/pdextract/setups_decl.h b/port/pdextract/setups_decl.h deleted file mode 100644 index e78afd62b..000000000 --- a/port/pdextract/setups_decl.h +++ /dev/null @@ -1,642 +0,0 @@ -#ifndef _IN_SETUP_DECL -#define _IN_SETUP_DECL - -#include "common.h" - - -struct n64_stagesetup { - u32 ptr_waypoints; - u32 ptr_waygroups; - u32 ptr_cover; - u32 ptr_intro; - u32 ptr_props; - u32 ptr_paths; - u32 ptr_ailists; - u32 ptr_padfiledata; -}; - - -struct n64_coord { - f32 x; - f32 y; - f32 z; -}; - -struct n64_defaultobj { - u16 extrascale; - u8 hidden2; - u8 type; - s16 modelnum; - s16 pad; - u32 flags; - u32 flags2; - u32 flags3; - u32 ptr_prop; - u32 ptr_model; - f32 realrot[3][3]; - u32 hidden; - union { - u32 ptr_geotilef; - u32 ptr_geoblock; - u32 ptr_geocyl; - u32 ptr_unkgeo; - }; - union { - u32 ptr_projectile; - u32 ptr_embedment; - }; - s16 damage; - s16 maxdamage; - u8 shadecol[4]; - u8 nextcol[4]; - u16 floorcol; - s8 geocount; - s8 _pad_; -}; - -struct n64_doorobj { - struct n64_defaultobj base; - f32 maxfrac; - f32 perimfrac; - f32 accel; - f32 decel; - f32 maxspeed; - u16 doorflags; - u16 doortype; - u32 keyflags; - s32 autoclosetime; - f32 frac; - f32 fracspeed; - s8 mode; - s8 glasshits; - s16 fadealpha; - s16 xludist; - s16 opadist; - struct n64_coord startpos; - f32 mtx98[3][3]; - u32 ptr_sibling; - s32 lastopen60; - s16 portalnum; - s8 soundtype; - s8 fadetime60; - s32 lastcalc60; - u8 laserfade; - u8 unusedmaybe[3]; - u8 shadeinfo1[4]; - u8 shadeinfo2[4]; - u8 actual1; - u8 actual2; - u8 extra1; - u8 extra2; -}; - -struct n64_doorscaleobj { - u32 unk00; - s32 scale; -}; - -struct n64_keyobj { - struct n64_defaultobj base; - u32 keyflags; -}; - -struct n64_alarmobj { - struct n64_defaultobj base; -}; - -struct n64_cctvobj { - struct n64_defaultobj base; - - s16 lookatpadnum; - s16 toleft; - //Mtxf camrotm; - f32 m[4][4]; - f32 yzero; - f32 yrot; - f32 yleft; - f32 yright; - f32 yspeed; - f32 ymaxspeed; - s32 seebondtime60; - f32 maxdist; - f32 xzero; -}; - -struct n64_ammocrateobj { - struct n64_defaultobj base; - s32 ammotype; -}; - -struct n64_gset { - u8 weaponnum; - u8 unk0639; - u8 unk063a; - u8 weaponfunc; -}; - -struct n64_weaponobj { - struct n64_defaultobj base; - - union { - struct n64_gset gset; - struct { - u8 weaponnum; - s8 unk5d; - s8 unk5e; - u8 gunfunc; - }; - }; - - s8 fadeouttimer60; - s8 dualweaponnum; - - union { - s16 timer240; - s16 team; - }; - - u32 ptr_dualweapon; -}; - -struct n64_packedchr { - s16 chrindex; - s8 unk02; - s8 typenum; - u32 spawnflags; - s16 chrnum; - u16 padnum; - u8 bodynum; - s8 headnum; - u16 ailistnum; - u16 padpreset; - u16 chrpreset; - u16 hearscale; - u16 viewdist; - u32 flags; - u32 flags2; - u8 team; - u8 squadron; - s16 chair; - u32 convtalk; - u8 tude; - u8 naturalanim; - u8 yvisang; - u8 teamscandist; -}; - -struct n64_tvscreen { - u32 ptr_cmdlist; - u16 offset; - s16 pause60; - u32 ptr_tconfig; - f32 rot; - f32 xscale; - f32 xscalefrac; - f32 xscaleinc; - f32 xscaleold; - f32 xscalenew; - f32 yscale; - f32 yscalefrac; - f32 yscaleinc; - f32 yscaleold; - f32 yscalenew; - f32 xmid; - f32 xmidfrac; - f32 xmidinc; - f32 xmidold; - f32 xmidnew; - f32 ymid; - f32 ymidfrac; - f32 ymidinc; - f32 ymidold; - f32 ymidnew; - u8 red; - u8 redold; - u8 rednew; - u8 green; - u8 greenold; - u8 greennew; - u8 blue; - u8 blueold; - u8 bluenew; - u8 alpha; - u8 alphaold; - u8 alphanew; - f32 colfrac; - f32 colinc; -}; - -struct n64_singlemonitorobj { - struct n64_defaultobj base; - struct n64_tvscreen screen; - s16 owneroffset; - s8 ownerpart; - u8 imagenum; -}; - -struct n64_multimonitorobj { - struct n64_defaultobj base; - struct n64_tvscreen screens[4]; - u8 imagenums[4]; -}; - -struct n64_hangingmonitorsobj { - struct n64_defaultobj base; -}; - -struct n64_autogunobj { - struct n64_defaultobj base; - s16 targetpad; - s8 firing; - u8 firecount; - f32 yzero; - f32 ymaxleft; - f32 ymaxright; - f32 yrot; - f32 yspeed; - f32 xzero; - f32 xrot; - f32 xspeed; - f32 maxspeed; - f32 aimdist; - f32 barrelspeed; - f32 barrelrot; - s32 lastseebond60; - s32 lastaimbond60; - s32 allowsoundframe; - u32 ptr_beam; - f32 shotbondsum; - u32 ptr_target; - u8 targetteam; - u8 ammoquantity; - s16 nextchrtest; -}; - -struct n64_linkgunsobj { - u32 unk00; - s16 offset1; - s16 offset2; -}; - -struct n64_debrisobj { - struct n64_defaultobj base; -}; - -struct n64_hatobj { - struct n64_defaultobj base; -}; - -struct n64_grenadeprobobj { // objtype 0x12 - u32 unk00; - s16 chrnum; - u16 probability; -}; - -struct n64_linkliftdoorobj { - u32 unk00; - u32 ptr_door; - u32 ptr_lift; - u32 ptr_next; - s32 stopnum; -}; - -struct n64_multiammocrateslot { - u16 modelnum; - u16 quantity; -}; - -struct n64_multiammocrateobj { - struct n64_defaultobj base; - struct n64_multiammocrateslot slots[19]; -}; - -struct n64_shieldobj { - struct n64_defaultobj base; - f32 initialamount; - f32 amount; - u32 unk64; -}; - -struct n64_tag { - u32 identifier; - u16 tagnum; - s16 cmdoffset; - u32 ptr_next; - u32 ptr_obj; -}; - -struct n64_objective { - u32 unk00; - s32 index; - u32 text; - u16 unk0c; - u8 flags; - s8 difficulties; -}; - -struct n64_stdobjective { - u32 cmd; -}; - -struct n64_objectivecmd { - u8 cmd0[4]; - u32 cmd1; -}; - -struct n64_briefingobj { - u32 unk00; - u32 type; - u32 text; - u32 ptr_next; -}; - -struct n64_padlockeddoorobj { - u32 unk00; - u32 ptr_door; - u32 ptr_lock; - u32 ptr_next; -}; - -struct n64_truckobj { - struct n64_defaultobj base; - u32 ptr_ailist; - u16 aioffset; - s16 aireturnlist; - f32 speed; - f32 wheelxrot; - f32 wheelyrot; - f32 speedaim; - f32 speedtime60; - f32 turnrot60; - f32 roty; - u32 ptr_path; - s32 nextstep; -}; - -struct n64_tankobj { - u8 _pad_[128]; -}; - -struct n64_heliobj { - struct n64_defaultobj base; - u32 ptr_ailist; - u16 aioffset; - s16 aireturnlist; - f32 rotoryrot; - f32 rotoryspeed; - f32 rotoryspeedaim; - f32 rotoryspeedtime; - f32 speed; - f32 speedaim; - f32 speedtime60; - f32 yrot; - u32 ptr_path; - s32 nextstep; -}; - -struct n64_glassobj { - struct n64_defaultobj base; - s16 portalnum; - s16 _pad_; -}; - -struct n64_safeobj { - struct n64_defaultobj base; -}; - -struct n64_safeitemobj { - u32 unk00; - u32 ptr_item; - u32 ptr_safe; - u32 ptr_door; - u32 ptr_next; -}; - -struct n64_cameraposobj { - s32 type; - f32 x; - f32 y; - f32 z; - f32 theta; - f32 verta; - s32 pad; -}; - -struct n64_tintedglassobj { - struct n64_defaultobj base; - s16 xludist; - s16 opadist; - s16 opacity; - s16 portalnum; - f32 unk64; -}; - -struct n64_liftobj { - struct n64_defaultobj base; - s16 pads[4]; - u32 ptr_doors[4]; - f32 dist; - f32 speed; - f32 accel; - f32 maxspeed; - s8 soundtype; - s8 levelcur; - s8 levelaim; - s8 _pad_; - struct n64_coord prevpos; -}; - -struct n64_linksceneryobj { - u32 unk00; - u32 ptr_trigger; - u32 ptr_unexp; - u32 ptr_exp; - u32 ptr_next; -}; - -struct n64_blockedpathobj { - u32 unk00; - u32 ptr_blocker; - s16 waypoint1; - s16 waypoint2; - u32 ptr_next; -}; - -struct n64_hov { - u8 type; - u8 flags; - s16 _pad_; - f32 bobycur; - f32 bobytarget; - f32 bobyspeed; - f32 yrot; - f32 bobpitchcur; - f32 bobpitchtarget; - f32 bobpitchspeed; - f32 bobrollcur; - f32 bobrolltarget; - f32 bobrollspeed; - f32 groundpitch; - f32 y; - f32 ground; - s32 prevframe60; - s32 prevgroundframe60; -}; - -struct n64_hoverbikeobj { - struct n64_defaultobj base; - struct n64_hov hov; - f32 speed[2]; - f32 prevpos[2]; - f32 w; - f32 rels[2]; - f32 exreal; - f32 ezreal; - f32 ezreal2; - f32 leanspeed; - f32 leandiff; - s32 maxspeedtime240; - f32 speedabs[2]; - f32 speedrel[2]; -}; - -struct n64_hoverpropobj { - struct n64_defaultobj base; - struct n64_hov hov; -}; - -struct n64_fanobj { - struct n64_defaultobj base; - f32 yrot; - f32 yrotprev; - f32 ymaxspeed; - f32 yspeed; - f32 yaccel; - s8 on; - u8 _pad_[3]; -}; - -struct n64_hovercarobj { - struct n64_defaultobj base; - u32 ptr_ailist; - u16 aioffset; - s16 aireturnlist; - f32 speed; - f32 speedaim; - f32 speedtime60; - f32 turnyspeed60; - f32 turnxspeed60; - f32 turnrot60; - f32 roty; - f32 rotx; - f32 rotz; - u32 ptr_path; - s32 nextstep; - s16 status; - s16 dead; - s16 deadtimer60; - s16 sparkstimer60; -}; - -struct n64_chopperobj { - struct n64_defaultobj base; - u32 ptr_ailist; - u16 aioffset; - s16 aireturnlist; - union { - struct { - f32 speed; - f32 speedaim; - f32 speedtime60; - }; - struct n64_coord fall; - }; - f32 turnyspeed60; - f32 turnxspeed60; - f32 turnrot60; - f32 roty; - f32 rotx; - f32 rotz; - u32 ptr_path; - s32 nextstep;// - s16 weaponsarmed; - s16 ontarget; - s16 target; - u8 attackmode; - u8 cw; - f32 vx; - f32 vy; - f32 vz; - f32 power; - f32 otx; - f32 oty; - f32 otz; - f32 bob; - f32 bobstrength; - s32 targetvisible; - s32 timer60; - s32 patroltimer60; - f32 gunturnyspeed60; - f32 gunturnxspeed60; - f32 gunroty; - f32 gunrotx; - f32 barrelrotspeed; - f32 barrelrot; - u32 ptr_fireslotthing; - s32 dead; -}; - -struct n64_escalatorobj { - struct n64_defaultobj base; - s32 frame; - struct n64_coord prevpos; -}; - -struct n64_textoverride { - u32 unk00; - s32 objoffset; - s32 weapon; - u32 obtaintext; - u32 ownertext; - u32 inventorytext; - u32 inventory2text; - u32 pickuptext; - u32 ptr_next; - u32 ptr_obj; -}; - -struct n64_criteria_roomentered { - u32 unk00; - u32 pad; - u32 status; - u32 ptr_next; -}; - -struct n64_criteria_throwinroom { - u32 unk00; - u32 unk04; - u32 pad; - u32 status; - u32 ptr_next; -}; - -struct n64_criteria_holograph { - u32 unk00; - u32 obj; - u32 status; - u32 ptr_next; -}; - -struct n64_ailist { - u32 ptr_list; - s32 id; -}; - -struct n64_path { - u32 ptr_pads; - u8 id; - u8 flags; - u16 len; -}; - -#endif \ No newline at end of file diff --git a/port/pdextract/util_gbi.c b/port/pdextract/util_gbi.c deleted file mode 100644 index d89aac769..000000000 --- a/port/pdextract/util_gbi.c +++ /dev/null @@ -1,209 +0,0 @@ -#include -#include -#include -#include "common.h" -#include "gbi.h" - -#ifdef FORCE_BE32 -#define HOST_DWORDS_PER_CMD 1 -#elif UINTPTR_MAX == 0xFFFFFFFFFFFFFFFFu -#define HOST_DWORDS_PER_CMD 2 -#else -#define HOST_DWORDS_PER_CMD 1 -#endif - -struct vtx { - s16 x; - s16 y; - s16 z; - u8 flags; - u8 colour; - s16 s; - s16 t; -}; - -struct texaddr { - u32 src; - u32 dst; -}; - -u32 m_Segments[16]; -u32 m_SrcVtxOffset; -u32 m_DstVtxOffset; - -struct texaddr m_TexAddrs[64]; -int m_NumTexAddr; - -void gbi_reset(void) -{ - for (int i = 0; i < ARRAYCOUNT(m_Segments); i++) { - m_Segments[i] = 0; - } - - m_SrcVtxOffset = 0; - m_DstVtxOffset = 0; - m_NumTexAddr = 0; -} - -void gbi_set_segment(int segment, u32 offset) -{ - m_Segments[segment] = offset & 0x00ffffff; -} - -void gbi_set_vtx(u32 src_offset, u32 dst_offset) -{ - m_SrcVtxOffset = src_offset & 0x00ffffff; - m_DstVtxOffset = dst_offset & 0x00ffffff; -} - -void gbi_add_tex_addr(u32 src_offset, u32 dst_offset) -{ - m_TexAddrs[m_NumTexAddr].src = src_offset & 0x00ffffff; - m_TexAddrs[m_NumTexAddr++].dst = dst_offset & 0x00ffffff; -} - -u32 gbi_find_tex_addr(u32 src_offset) -{ - for (int i = 0; i < m_NumTexAddr; i++) { - if (m_TexAddrs[i].src == src_offset) - return m_TexAddrs[i].dst; - } - - return 0; -} - -void gbi_convert_vtx(u8 *dst, u32 offset, int count) -{ - if (!offset) return; - struct vtx* vtxs = (struct vtx*)(dst + offset); - - for (int i = 0; i < count; i++) { - struct vtx* vtx = &vtxs[i]; - - vtx->x = srctodst16(vtx->x); - vtx->y = srctodst16(vtx->y); - vtx->z = srctodst16(vtx->z); - vtx->s = srctodst16(vtx->s); - vtx->t = srctodst16(vtx->t); - } -} - -#define CMD_IS_VTX(cmd) ((cmd & 0xff00000000000000) == 0x0400000000000000) -#define CMD_IS_DL(cmd) ((cmd & 0xff00000000000000) == 0x0600000000000000) -#define CMD_IS_COL(cmd) ((cmd & 0xff00000000000000) == 0x0700000000000000) -#define CMD_IS_ENDDL(cmd) ((cmd & 0xff00000000000000) == 0xb800000000000000) -#define CMD_IS_MOVEWORD(cmd) ((cmd & 0xff00000000000000) == 0xbc00000000000000) -#define CMD_IS_MOVEMEM(cmd) ((cmd & 0xff00000000000000) == 0x0300000000000000) -#define CMD_IS_MTX(cmd) ((cmd & 0xff00000000000000) == 0x0100000000000000) -#define CMD_IS_SETTIMG(cmd) ((cmd & 0xff00000000000000) == 0xfd00000000000000) -#define CMD_IS_SETZIMG(cmd) ((cmd & 0xff00000000000000) == 0xfe00000000000000) -#define CMD_IS_SETCIMG(cmd) ((cmd & 0xff00000000000000) == 0xff00000000000000) - -#define CMD_HAS_ADDR(cmd) CMD_IS_VTX(cmd) \ - || CMD_IS_COL(cmd) \ - || CMD_IS_MOVEWORD(cmd) \ - || CMD_IS_SETTIMG(cmd) - - -#define CMD_IS_SEGMENTED(cmd) ( CMD_IS_MOVEMEM(cmd) \ - || CMD_IS_MTX(cmd) \ - || CMD_IS_VTX(cmd) \ - || CMD_IS_COL(cmd) \ - || CMD_IS_DL(cmd) \ - || CMD_IS_SETTIMG(cmd) \ - || CMD_IS_SETCIMG(cmd) \ - || CMD_IS_SETZIMG(cmd)) - -/** - * Segment 5 is the start of the model file. The data in these files shifts - * depending on the pointer size, so this function adjusts the offset accordingly. - */ -static u64 gbi_rewrite_addr(u64 cmd, u8 opcode) -{ - u8 segment = (cmd & 0x0f000000) >> 24; - u32 offset = cmd & 0x00ffffff; - - if (segment == 5) { - if (opcode == 0xfd) { - offset = gbi_find_tex_addr(offset); - } - else { - if (offset < m_SrcVtxOffset) { - printf("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, m_SrcVtxOffset); - exit(EXIT_FAILURE); - } - - offset = offset - m_SrcVtxOffset + m_DstVtxOffset; - } - } - - return (cmd & 0xffffffffff000000) | offset; -} - -void gbi_gdl_rewrite_addrs(u8 *dst, u32 offset) -{ - if (!offset) return; - - u64 *cmds = (u64 *)(dst + (offset & 0x00ffffff)); - if (!cmds) return; - - u64 cmd; - - do { - cmd = *cmds; - Gfx* gfxcmd = cmds; - int idx = 0; - u8 opcode = (cmd >> 24) & 0xff; - -#if HOST_DWORDS_PER_CMD == 2 - idx = 1; - opcode = (cmd >> 24) & 0xff; -#endif - cmd = (u64)opcode << 56; - - if (CMD_HAS_ADDR(cmd)) { - cmds[idx] = gbi_rewrite_addr(cmds[idx], opcode); - } - - if (CMD_IS_SEGMENTED(cmd)) { - gfxcmd->words.w1 |= 1; - } - - cmds += HOST_DWORDS_PER_CMD; - } while (!CMD_IS_ENDDL(cmd)); -} - -u32 gbi_convert_gdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds) -{ - dstpos = ALIGN8(dstpos); - - u64 *n64_cmd = (u64*)&src[srcpos]; - u64 *host_cmd = (u64*)&dst[dstpos]; - u64 cmd; - - do { - cmd = srctoh64(*n64_cmd); - -#if HOST_DWORDS_PER_CMD == 2 - host_cmd[0] = htodst64((cmd & 0xffffffff00000000) >> 32); - host_cmd[1] = htodst64(cmd & 0xffffffff); - - if (segment_cmds && CMD_IS_SEGMENTED(cmd)) { - host_cmd[1] |= 1; - } -#else - host_cmd[0] = (cmd >> 32) | ((cmd & 0xffffffff) << 32); - - if (segment_cmds && CMD_IS_SEGMENTED(cmd)) { - Gfx* gfxcmd = (Gfx*)host_cmd; - gfxcmd->words.w1 |= 1; - } -#endif - - dstpos += sizeof(*host_cmd) * HOST_DWORDS_PER_CMD; - host_cmd += HOST_DWORDS_PER_CMD; - n64_cmd++; - } while (!CMD_IS_ENDDL(cmd)); - - return dstpos; -} From 5bee1b0ccec444ba44bab33de24be7300308d465 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 00:50:21 +0800 Subject: [PATCH 39/81] portx64: a couple things breaking the build in github --- include/PR/os_pi.h | 2 +- port/include/preprocess.h | 5 +++-- src/lib/ultra/io/pidma.c | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/include/PR/os_pi.h b/include/PR/os_pi.h index 500ec916f..0c7459784 100644 --- a/include/PR/os_pi.h +++ b/include/PR/os_pi.h @@ -198,7 +198,7 @@ extern u32 osPiGetStatus(void); extern s32 osPiGetDeviceType(void); extern s32 osPiWriteIo(u32, u32); extern s32 osPiReadIo(u32, u32 *); -extern s32 osPiStartDma(OSIoMesg *, s32, s32, uintptr_t, void *, u32, +extern s32 osPiStartDma(OSIoMesg *, s32, s32, u32, void *, u32, OSMesgQueue *); extern void osCreatePiManager(OSPri, OSMesgQueue *, OSMesg *, s32); diff --git a/port/include/preprocess.h b/port/include/preprocess.h index c8734c1cd..36b19d9f5 100644 --- a/port/include/preprocess.h +++ b/port/include/preprocess.h @@ -14,11 +14,12 @@ void preprocessALCMidiHdr(u8 *data, u32 size); u8* preprocessSequences(u8 *data, u32 size, u32 *outSize); u8* preprocessTexturesList(u8 *data, u32 size, u32 *outSize); +void preprocessBgSection1(u8* data, u32 size); +void preprocessBgSection2(u8 *data, u32 size); +void preprocessBgSection3(u8* data, u32 size); void preprocessBgSection1Header(u8 *data, u32 size); void preprocessBgSection2Header(u8 *data, u32 size); -void preprocessBgSection2(u8 *data, u32 size); void preprocessBgSection3Header(u8 *data, u32 size); -void preprocessBgSection3(u8 *data, u32 size); void preprocessBgLights(u8 *data, u32 ofs); u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize); diff --git a/src/lib/ultra/io/pidma.c b/src/lib/ultra/io/pidma.c index 1fc7b61d7..75d758d1b 100644 --- a/src/lib/ultra/io/pidma.c +++ b/src/lib/ultra/io/pidma.c @@ -1,7 +1,7 @@ #include #include "piint.h" -s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, uintptr_t devAddr, void *dramAddr, u32 size, OSMesgQueue *mq) +s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, u32 devAddr, void *dramAddr, u32 size, OSMesgQueue *mq) { register s32 ret; From a9e82658fd96329a7e3f9963d90dea11f5d999c3 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 01:21:28 +0800 Subject: [PATCH 40/81] portx64: a couple things breaking the build in github - actual fix, plus renamed more functions in filebg.c --- include/PR/os_pi.h | 4 ++-- port/include/preprocess.h | 3 ++- port/src/preprocess/filebg.c | 24 ++---------------------- src/lib/ultra/io/pidma.c | 2 +- 4 files changed, 7 insertions(+), 26 deletions(-) diff --git a/include/PR/os_pi.h b/include/PR/os_pi.h index 0c7459784..eca4eae88 100644 --- a/include/PR/os_pi.h +++ b/include/PR/os_pi.h @@ -37,7 +37,7 @@ extern "C" { #include #include "os_thread.h" #include "os_message.h" - +#include #if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) @@ -198,7 +198,7 @@ extern u32 osPiGetStatus(void); extern s32 osPiGetDeviceType(void); extern s32 osPiWriteIo(u32, u32); extern s32 osPiReadIo(u32, u32 *); -extern s32 osPiStartDma(OSIoMesg *, s32, s32, u32, void *, u32, +extern s32 osPiStartDma(OSIoMesg *, s32, s32, uintptr_t, void *, u32, OSMesgQueue *); extern void osCreatePiManager(OSPri, OSMesgQueue *, OSMesg *, s32); diff --git a/port/include/preprocess.h b/port/include/preprocess.h index 36b19d9f5..6c0fd609b 100644 --- a/port/include/preprocess.h +++ b/port/include/preprocess.h @@ -14,13 +14,14 @@ void preprocessALCMidiHdr(u8 *data, u32 size); u8* preprocessSequences(u8 *data, u32 size, u32 *outSize); u8* preprocessTexturesList(u8 *data, u32 size, u32 *outSize); -void preprocessBgSection1(u8* data, u32 size); +void preprocessBgSection1(u8* data, u32 size, u32 ofs); void preprocessBgSection2(u8 *data, u32 size); void preprocessBgSection3(u8* data, u32 size); void preprocessBgSection1Header(u8 *data, u32 size); void preprocessBgSection2Header(u8 *data, u32 size); void preprocessBgSection3Header(u8 *data, u32 size); void preprocessBgLights(u8 *data, u32 ofs); +u32 preprocessBgRoom(u8* data, u32 size, u32 room_ofs); u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize); u8 *preprocessPadsFile(u8 *data, u32 size, u32 *outSize); diff --git a/port/src/preprocess/filebg.c b/port/src/preprocess/filebg.c index b592e1e18..33dc5f156 100644 --- a/port/src/preprocess/filebg.c +++ b/port/src/preprocess/filebg.c @@ -515,7 +515,7 @@ static u32 convertSection1(u8 *dst, u8 *src, u32 ofs) return dstpos; } -static void convert_section2_texturenums(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 srclen) +static void convertSection2TextureNums(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 srclen) { u16 *src_ids = (u16 *) &src[*srcpos]; u16 *dst_ids = (u16 *) &dst[*dstpos]; @@ -529,7 +529,7 @@ static void convert_section2_texturenums(u8 *dst, u32 *dstpos, u8 *src, u32 *src *dstpos += srclen; } -static void convert_section3_bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) +static void convertSection3Bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { s16 *src_bboxes = (s16 *) &src[*srcpos]; s16 *dst_bboxes = (s16 *) &dst[*dstpos]; @@ -547,26 +547,6 @@ static void convert_section3_bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) *dstpos += sizeof(s16) * 6 * (m_NumRooms - 1); } -static void convert_section3_allocsizes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) -{ - u16 *dst_sizes = (u16 *) &dst[*dstpos]; - - for (int i = 0; i < m_NumRooms; i++) { - dst_sizes[i] = (m_AllocSizes[i] - 0x100) / 0x10; - } - - *srcpos += sizeof(u16) * (m_NumRooms - 1); - *dstpos += sizeof(u16) * (m_NumRooms - 1); -} - -static void convert_section3_lightcounts(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) -{ - memcpy(&dst[*dstpos], &src[*srcpos], m_NumRooms); - - *srcpos += (m_NumRooms - 1); - *dstpos += (m_NumRooms - 1); -} - void preprocessBgSection1(u8 *data, u32 size, u32 ofs) { u8 *dst = sysMemZeroAlloc(size); diff --git a/src/lib/ultra/io/pidma.c b/src/lib/ultra/io/pidma.c index 75d758d1b..1fc7b61d7 100644 --- a/src/lib/ultra/io/pidma.c +++ b/src/lib/ultra/io/pidma.c @@ -1,7 +1,7 @@ #include #include "piint.h" -s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, u32 devAddr, void *dramAddr, u32 size, OSMesgQueue *mq) +s32 osPiStartDma(OSIoMesg *mb, s32 priority, s32 direction, uintptr_t devAddr, void *dramAddr, u32 size, OSMesgQueue *mq) { register s32 ret; From 01cbcd99cb6983343b3ae60c573e903b4f17417a Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 02:31:10 +0800 Subject: [PATCH 41/81] portx64: fixed a bunch of instances of Wincompatible-pointer-types + filesetup.c: use ALIGN macro --- port/src/preprocess/filebg.c | 18 +++++++++--------- port/src/preprocess/filesetup.c | 5 ++--- src/game/bondgun.c | 2 +- src/include/types.h | 2 +- 4 files changed, 13 insertions(+), 14 deletions(-) diff --git a/port/src/preprocess/filebg.c b/port/src/preprocess/filebg.c index 33dc5f156..95c909694 100644 --- a/port/src/preprocess/filebg.c +++ b/port/src/preprocess/filebg.c @@ -300,7 +300,7 @@ static void convertPrimaryLights(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 #define BLOCK_LEAF 0 #define BLOCK_PARENT 1 -void relinkPtr(uintptr_t** ptr) +void relinkPtr(uintptr_t* ptr) { if (!*ptr) return; @@ -455,10 +455,10 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) for (size_t i = 0; i < numblocks; i++) { struct host_roomblock *block = (struct host_roomblock*)&ptr_dst_roomblocks[i]; - relinkPtr(&block->ptr_next); + relinkPtr((uintptr_t*)&block->ptr_next); if (block->type == BLOCK_LEAF) { - relinkPtr(&block->ptr_gdl); + relinkPtr((uintptr_t*)&block->ptr_gdl); u32 offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; u32 offset_col = block->ptr_colours - ptr_src_colors - src_ofs; @@ -466,16 +466,16 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) block->ptr_colours = ptr_dst_colors + offset_col; } else { - relinkPtr(&block->ptr_gdl); // child - relinkPtr(&block->ptr_vertices); // coord + relinkPtr((uintptr_t*)&block->ptr_gdl); // child + relinkPtr((uintptr_t*)&block->ptr_vertices); // coord } } // relink ptrs: header - relinkPtr(&dst_header->ptr_vertices); - relinkPtr(&dst_header->ptr_colours); - relinkPtr(&dst_header->ptr_opablocks); - relinkPtr(&dst_header->ptr_xlublocks); + relinkPtr((uintptr_t*)&dst_header->ptr_vertices); + relinkPtr((uintptr_t*)&dst_header->ptr_colours); + relinkPtr((uintptr_t*)&dst_header->ptr_opablocks); + relinkPtr((uintptr_t*)&dst_header->ptr_xlublocks); return curpos_dst; } diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index 9d4c9c7b2..2c4e8e977 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -1138,8 +1138,7 @@ static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) u32 listsize = chraiGetAilistLength(list); memcpy(dst + dstpos, list, listsize); - // align to the next multiple of 4 - dstpos += ((listsize + 3) >> 2) << 2; + dstpos += ALIGN(listsize, 4); } return dstpos; @@ -1177,7 +1176,7 @@ static int convertSetup(u8 *dst, u8 *src, u32 srclen) dst_header->paths = (struct path*) dstpos; dstpos += convertPaths(&dst[dstpos], &src[srcpos]); - dstpos += convertPads(&dst[(uintptr_t)dst_header->paths], dst, src, dstpos); + dstpos += convertPads((struct path*)&dst[(uintptr_t)dst_header->paths], dst, src, dstpos); return dstpos; } diff --git a/src/game/bondgun.c b/src/game/bondgun.c index e0e04a49d..e3359415d 100644 --- a/src/game/bondgun.c +++ b/src/game/bondgun.c @@ -4192,7 +4192,7 @@ void bgunTickMasterLoad(void) modelInit(&hand->handmodel, player->gunctrl.handmodeldef, hand->handsavedata, false); } - hand->unk0dcc = (s32 *) player->gunctrl.memloadptr; + hand->unk0dcc = (uintptr_t *) player->gunctrl.memloadptr; value = bgunCreateModelCmdList(&hand->gunmodel, player->gunctrl.gunmodeldef->rootnode, (uintptr_t *) player->gunctrl.memloadptr); diff --git a/src/include/types.h b/src/include/types.h index 3b761854c..bfc30039a 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -2306,7 +2306,7 @@ struct hand { /*0x0dbc*/ u32 fspare7; /*0x0dc0*/ u32 fspare8; /*0x0dc4*/ struct abmag abmag; - /*0x0dcc*/ s32 *unk0dcc; + /*0x0dcc*/ uintptr_t *unk0dcc; /*0x0dd0*/ uintptr_t *unk0dd0; /*0x0dd4*/ s32 unk0dd4; /*0x0dd8*/ Mtxf *unk0dd8; From d2dd109a052d25b1074c1f7d979d38f40dc2a6d7 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 03:57:01 +0800 Subject: [PATCH 42/81] portx64: a bunch of gcc14 fixes --- port/src/preprocess/common.h | 1 + port/src/preprocess/filemodel.c | 43 +++++++-------- port/src/preprocess/filesetup.c | 95 ++++++++++++++++----------------- port/src/preprocess/util_gbi.c | 2 +- src/game/file.c | 2 +- src/game/menuitem.c | 2 +- 6 files changed, 73 insertions(+), 72 deletions(-) diff --git a/port/src/preprocess/common.h b/port/src/preprocess/common.h index 0f9930d94..b75c6517f 100644 --- a/port/src/preprocess/common.h +++ b/port/src/preprocess/common.h @@ -4,6 +4,7 @@ #include #include #include +#include #include // this BS comes from windows.h diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index 5edece56e..79aa8a9f7 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -315,11 +315,11 @@ struct dst_texconfig { u8 unk0b; }; -static inline void *minPtr(void *a, void *b) { +static inline uintptr_t minPtr(uintptr_t a, uintptr_t b) { return (a && (a < b || !b)) ? a : b; } -static inline void *minPtr3(void *a, void *b, void *c) { +static inline uintptr_t minPtr3(uintptr_t a, uintptr_t b, uintptr_t c) { return minPtr(minPtr(a, b), c); } @@ -781,14 +781,14 @@ static u32 resolvePointer(u32 src_offset) static u8 *relinkPointers(u8 *dst, u8 *src) { - u8 *textures_end = 0; + uintptr_t textures_end = 0; for (int i = 0; i < m_NumMarkers; i++) { struct marker *marker = &m_Markers[i]; void *src_thing = &src[marker->src_offset]; void *dst_thing = &dst[marker->dst_offset]; - u8 *lowestptr = 0; + uintptr_t lowestptr = 0; switch (marker->type) { case CT_MODELDEF: @@ -913,6 +913,7 @@ static u8 *relinkPointers(u8 *dst, u8 *src) break; case CT_TEXDATA: case CT_VTXCOL: + case CT_VTXCOL4: case CT_GDL: case CT_RODATA_BBOX: case CT_RODATA_11: @@ -925,31 +926,17 @@ static u8 *relinkPointers(u8 *dst, u8 *src) textures_end = minPtr(textures_end, lowestptr); } - return textures_end; + return (u8*)textures_end; } -static int convertModel(u8 *dst, u8 *src, u32 srclen) -{ - u32 dstpos; - - populateMarkers(src); - sortMarkers(); - - dstpos = convertContent(dst, src, srclen); - u8 *tex_end = relinkPointers(dst, src); - preprocessModelTextures(dst, tex_end); - - return dstpos; -} - -void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) +static void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) { for (uint32_t i = 0; i < size_bytes; i += 4, ++dest) { *dest = PD_BE32(*dest); } } -void preprocessModelTextures(u8 *base, u8 *textures_end) +static void preprocessModelTextures(u8 *base, u8 *textures_end) { struct modeldef* mdl = (struct modeldef*)base; if (!mdl->texconfigs) return; @@ -976,6 +963,20 @@ void preprocessModelTextures(u8 *base, u8 *textures_end) } } +static int convertModel(u8* dst, u8* src, u32 srclen) +{ + u32 dstpos; + + populateMarkers(src); + sortMarkers(); + + dstpos = convertContent(dst, src, srclen); + u8* tex_end = relinkPointers(dst, src); + preprocessModelTextures(dst, tex_end); + + return dstpos; +} + u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize) { gbiReset(); diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index 2c4e8e977..3e22a71d0 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -40,7 +40,7 @@ static u32 convUnk(void* x, u32 y) { __debugbreak(); } for (int j = 0; j < ARRAYCOUNT(dst); j++) PD_CONV_VAL(dst[i][j], src[i][j]); \ } -#define PD_CONV_PTR(dst, src) dst = srctoh32(src) +#define PD_CONV_PTR(dst, src, type) dst = (type)srctoh32(src) static u32 obj_size(struct n64_defaultobj *obj) { @@ -109,10 +109,10 @@ static u32 obj_size(struct n64_defaultobj *obj) void conv_tvscreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) { - PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist); + PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist, u32*); PD_CONV_VAL(dstobj->offset, srcobj->offset); PD_CONV_VAL(dstobj->pause60, srcobj->pause60); - PD_CONV_PTR(dstobj->tconfig, srcobj->ptr_tconfig); + PD_CONV_PTR(dstobj->tconfig, srcobj->ptr_tconfig, struct textureconfig*); PD_CONV_VAL(dstobj->rot, srcobj->rot); PD_CONV_VAL(dstobj->xscale, srcobj->xscale); PD_CONV_VAL(dstobj->xscalefrac, srcobj->xscalefrac); @@ -180,12 +180,11 @@ void convertDefaultObj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) PD_CONV_VAL(dstobj->flags, srcobj->flags); PD_CONV_VAL(dstobj->flags2, srcobj->flags2); PD_CONV_VAL(dstobj->flags3, srcobj->flags3); - PD_CONV_PTR(dstobj->prop, srcobj->ptr_prop); - PD_CONV_PTR(dstobj->model, srcobj->ptr_model); + PD_CONV_PTR(dstobj->prop, srcobj->ptr_prop, struct prop*); + PD_CONV_PTR(dstobj->model, srcobj->ptr_model, struct model*); PD_CONV_ARRAY2D(dstobj->realrot, srcobj->realrot); PD_CONV_VAL(dstobj->hidden, srcobj->hidden); - PD_CONV_PTR(dstobj->unkgeo, srcobj->ptr_unkgeo); - PD_CONV_PTR(dstobj->embedment, srcobj->ptr_embedment); + PD_CONV_PTR(dstobj->unkgeo, srcobj->ptr_unkgeo, struct geocyl*); PD_CONV_VAL(dstobj->damage, srcobj->damage); PD_CONV_VAL(dstobj->maxdamage, srcobj->maxdamage); PD_CONV_ARRAY(dstobj->shadecol, srcobj->shadecol); @@ -230,7 +229,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->opadist, srcobj->opadist); PD_CONV_VAL(dstobj->startpos, srcobj->startpos); PD_CONV_ARRAY2D(dstobj->mtx98, srcobj->mtx98); - PD_CONV_PTR(dstobj->sibling, srcobj->ptr_sibling); + PD_CONV_PTR(dstobj->sibling, srcobj->ptr_sibling, struct doorobj*); PD_CONV_VAL(dstobj->lastopen60, srcobj->lastopen60); PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); @@ -337,7 +336,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->team, srcobj->team); - PD_CONV_PTR(dstobj->dualweapon, srcobj->ptr_dualweapon); + PD_CONV_PTR(dstobj->dualweapon, srcobj->ptr_dualweapon, struct weaponobj*); dst += sizeof(struct weaponobj); break; @@ -428,9 +427,9 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->lastseebond60, srcobj->lastseebond60); PD_CONV_VAL(dstobj->lastaimbond60, srcobj->lastaimbond60); PD_CONV_VAL(dstobj->allowsoundframe, srcobj->allowsoundframe); - PD_CONV_PTR(dstobj->beam, srcobj->ptr_beam); + PD_CONV_PTR(dstobj->beam, srcobj->ptr_beam, struct beam*); PD_CONV_VAL(dstobj->shotbondsum, srcobj->shotbondsum); - PD_CONV_PTR(dstobj->target, srcobj->ptr_target); + PD_CONV_PTR(dstobj->target, srcobj->ptr_target, struct prop*); PD_CONV_VAL(dstobj->targetteam, srcobj->targetteam); PD_CONV_VAL(dstobj->ammoquantity, srcobj->ammoquantity); PD_CONV_VAL(dstobj->nextchrtest, srcobj->nextchrtest); @@ -468,9 +467,9 @@ u32 convertProps(u8* dst, u8* src) struct linkliftdoorobj* dstobj = (struct linkliftdoorobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->lift, srcobj->ptr_lift); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door, struct prop*); + PD_CONV_PTR(dstobj->lift, srcobj->ptr_lift, struct prop*); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct linkliftdoorobj*); PD_CONV_VAL(dstobj->stopnum, srcobj->stopnum); dst += sizeof(struct linkliftdoorobj); @@ -513,8 +512,8 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->tagnum, srcobj->tagnum); PD_CONV_VAL(dstobj->cmdoffset, srcobj->cmdoffset); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct tag*); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj, struct defaultobj*); dst += sizeof(struct tag); break; @@ -572,7 +571,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->obj, srcobj->obj); PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct criteria_holograph*); dst += sizeof(struct criteria_holograph); break; @@ -585,7 +584,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->pad, srcobj->pad); PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct criteria_roomentered*); dst += sizeof(struct criteria_roomentered); break; @@ -598,7 +597,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->pad, srcobj->pad); PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct criteria_throwinroom*); dst += sizeof(struct criteria_throwinroom); break; @@ -611,7 +610,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->type, srcobj->type); PD_CONV_VAL(dstobj->text, srcobj->text); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct briefingobj*); dst += sizeof(struct briefingobj); break; @@ -629,8 +628,8 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->inventorytext, srcobj->inventorytext); PD_CONV_VAL(dstobj->inventory2text, srcobj->inventory2text); PD_CONV_VAL(dstobj->pickuptext, srcobj->pickuptext); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct textoverride*); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj, struct defaultobj*); dst += sizeof(struct textoverride); break; @@ -641,9 +640,9 @@ u32 convertProps(u8* dst, u8* src) struct padlockeddoorobj* dstobj = (struct padlockeddoorobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->lock, srcobj->ptr_lock); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door, struct doorobj*); + PD_CONV_PTR(dstobj->lock, srcobj->ptr_lock, struct defaultobj*); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct padlockeddoorobj*); dst += sizeof(struct padlockeddoorobj); break; @@ -655,7 +654,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist, u8*); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -665,7 +664,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); PD_CONV_VAL(dstobj->roty, srcobj->roty); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path, struct path*); PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); dst += sizeof(struct truckobj); @@ -678,7 +677,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist, u8*); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->rotoryrot, srcobj->rotoryrot); @@ -689,7 +688,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); PD_CONV_VAL(dstobj->yrot, srcobj->yrot); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path, struct path*); PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); dst += sizeof(struct heliobj); @@ -712,10 +711,10 @@ u32 convertProps(u8* dst, u8* src) struct safeitemobj* dstobj = (struct safeitemobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->item, srcobj->ptr_item); - PD_CONV_PTR(dstobj->safe, srcobj->ptr_safe); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->item, srcobj->ptr_item, struct defaultobj*); + PD_CONV_PTR(dstobj->safe, srcobj->ptr_safe, struct safeobj*); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door, struct doorobj*); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct safeitemobj*); dst += sizeof(struct safeitemobj); break; @@ -766,7 +765,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_ARRAY(dstobj->pads, srcobj->pads); for (int k = 0; k < 4; k++) - PD_CONV_PTR(dstobj->doors[k], srcobj->ptr_doors[k]); + PD_CONV_PTR(dstobj->doors[k], srcobj->ptr_doors[k], struct doorobj*); PD_CONV_VAL(dstobj->dist, srcobj->dist); PD_CONV_VAL(dstobj->speed, srcobj->speed); PD_CONV_VAL(dstobj->accel, srcobj->accel); @@ -785,10 +784,10 @@ u32 convertProps(u8* dst, u8* src) struct linksceneryobj* dstobj = (struct linksceneryobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->trigger, srcobj->ptr_trigger); - PD_CONV_PTR(dstobj->unexp, srcobj->ptr_unexp); - PD_CONV_PTR(dstobj->exp, srcobj->ptr_exp); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->trigger, srcobj->ptr_trigger, struct defaultobj*); + PD_CONV_PTR(dstobj->unexp, srcobj->ptr_unexp, struct defaultobj*); + PD_CONV_PTR(dstobj->exp, srcobj->ptr_exp, struct defaultobj*); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct linksceneryobj*); dst += sizeof(struct linksceneryobj); break; @@ -799,10 +798,10 @@ u32 convertProps(u8* dst, u8* src) struct blockedpathobj* dstobj = (struct blockedpathobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->blocker, srcobj->ptr_blocker); + PD_CONV_PTR(dstobj->blocker, srcobj->ptr_blocker, struct defaultobj*); PD_CONV_VAL(dstobj->waypoint1, srcobj->waypoint1); PD_CONV_VAL(dstobj->waypoint2, srcobj->waypoint2); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct blockedpathobj*); dst += sizeof(struct blockedpathobj); break; @@ -898,7 +897,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist, u8*); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -910,7 +909,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->roty, srcobj->roty); PD_CONV_VAL(dstobj->rotx, srcobj->rotx); PD_CONV_VAL(dstobj->rotz, srcobj->rotz); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path, struct path*); PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); PD_CONV_VAL(dstobj->status, srcobj->status); PD_CONV_VAL(dstobj->dead, srcobj->dead); @@ -939,7 +938,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist, u8*); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -951,7 +950,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->roty, srcobj->roty); PD_CONV_VAL(dstobj->rotx, srcobj->rotx); PD_CONV_VAL(dstobj->rotz, srcobj->rotz); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path, struct path*); PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); PD_CONV_VAL(dstobj->weaponsarmed, srcobj->weaponsarmed); PD_CONV_VAL(dstobj->ontarget, srcobj->ontarget); @@ -976,7 +975,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->gunrotx, srcobj->gunrotx); PD_CONV_VAL(dstobj->barrelrotspeed, srcobj->barrelrotspeed); PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); - PD_CONV_PTR(dstobj->fireslotthing, srcobj->ptr_fireslotthing); + PD_CONV_PTR(dstobj->fireslotthing, srcobj->ptr_fireslotthing, struct fireslotthing*); PD_CONV_VAL(dstobj->dead, srcobj->dead); dst += sizeof(struct chopperobj); @@ -1050,7 +1049,7 @@ static u32 convertPaths(u8 *dst, u8 *src) struct path* dstpath = (struct path*)dst; while (true) { - PD_CONV_PTR(dstpath->pads, srcpath->ptr_pads); + PD_CONV_PTR(dstpath->pads, srcpath->ptr_pads, s32*); PD_CONV_VAL(dstpath->id, srcpath->id); PD_CONV_VAL(dstpath->flags, srcpath->flags); PD_CONV_VAL(dstpath->len, srcpath->len); @@ -1093,7 +1092,7 @@ static u32 convertAiLists(u8* dst, u8* src) while (true) { // at this point these fields are already converted, so we just assign - dstailist->list = srcailist->ptr_list; + dstailist->list = (u8*)srcailist->ptr_list; dstailist->id = srcailist->id; @@ -1123,7 +1122,7 @@ static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) for (struct n64_ailist *ailist = src_ailists; ailist->ptr_list; ailist++) { // update the src list pointers here uintptr_t src_ptr_list = (uintptr_t) ailist->ptr_list; - ailist->ptr_list = (u8*)dstpos; + ailist->ptr_list = dstpos; // multiple ailists can point to the same list, so we need to check if it was already copied struct ptrmarker *marker = findPtrMarker(src_ptr_list); diff --git a/port/src/preprocess/util_gbi.c b/port/src/preprocess/util_gbi.c index 75b4a621a..680d22e75 100644 --- a/port/src/preprocess/util_gbi.c +++ b/port/src/preprocess/util_gbi.c @@ -151,7 +151,7 @@ void gbiGdlRewriteAddrs(u8 *dst, u32 offset) do { cmd = *cmds; - Gfx* gfxcmd = cmds; + Gfx* gfxcmd = (Gfx *)cmds; int idx = 0; u8 opcode = (cmd >> 24) & 0xff; diff --git a/src/game/file.c b/src/game/file.c index 6c188338c..825ebf7c1 100644 --- a/src/game/file.c +++ b/src/game/file.c @@ -4259,7 +4259,7 @@ u32 fileGetInflatedSize(s32 filenum, FileType filetype) { u8 *ptr; u8 buffer[0x50]; - u32 *romaddrptr; + uintptr_t *romaddrptr; #if VERSION < VERSION_NTSC_1_0 char message[128]; #endif diff --git a/src/game/menuitem.c b/src/game/menuitem.c index f456bfe27..c95acb89e 100644 --- a/src/game/menuitem.c +++ b/src/game/menuitem.c @@ -799,7 +799,7 @@ bool menuitemListTick(struct menuitem *item, struct menuinputs *inputs, u32 tick void menuitemDropdownInit(struct menuitem *item, union menuitemdata *data) { - s32 (*handler)(s32 operation, struct menuitem *item, union handlerdata *data); + uintptr_t (*handler)(s32 operation, struct menuitem *item, union handlerdata *data); union handlerdata handlerdata; union handlerdata handlerdata2; From a5d9f021843fcd77e7527f92f6947627263a75eb Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 04:22:57 +0800 Subject: [PATCH 43/81] portx64: fixed pal --- port/src/preprocess/segfonts.c | 2 +- src/game/lang.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/port/src/preprocess/segfonts.c b/port/src/preprocess/segfonts.c index b2f9ab1b8..e201d21ee 100644 --- a/port/src/preprocess/segfonts.c +++ b/port/src/preprocess/segfonts.c @@ -59,7 +59,7 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) if (src == _fonthandelgothicsmSegmentRomStart || src == _fonthandelgothicxsSegmentRomStart || src == _fonthandelgothicmdSegmentRomStart) { - numchars = 135; + num_chars = 135; } #endif diff --git a/src/game/lang.c b/src/game/lang.c index bd97e6c1f..65565b496 100644 --- a/src/game/lang.c +++ b/src/game/lang.c @@ -377,7 +377,7 @@ s32 langGetFileId(s32 bank) void langLoad(s32 bank) { #if VERSION >= VERSION_PAL_BETA - s32 len = fileGetInflatedSize(langGetFileId(bank)); + s32 len = fileGetInflatedSize(langGetFileId(bank), LOADTYPE_LANG); if ((uintptr_t)g_LangBuffer + len + g_LangBufferSize - (uintptr_t)g_LangBufferPos >= 0) { s32 len2 = (uintptr_t)g_LangBuffer + g_LangBufferSize - (uintptr_t)g_LangBufferPos; From e09aebebe7a10ae95c19592098f63dfb2f8f3b48 Mon Sep 17 00:00:00 2001 From: Raf Date: Fri, 9 Aug 2024 04:45:12 +0800 Subject: [PATCH 44/81] Update c-cpp.yml --- .github/workflows/c-cpp.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 6b2b689b8..8c5d673f5 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -40,7 +40,7 @@ jobs: cp build/ntsc-final-port/pd.exe bin/ cp build/pal-final-port/pd.pal.exe bin/ cp build/jpn-final-port/pd.jpn.exe bin/ - cp /mingw64/bin/{SDL2.dll,zlib1.dll,libgcc_s_dw2-1.dll,libwinpthread-1.dll} bin/ + cp /mingw64/bin/{SDL2.dll,zlib1.dll,libwinpthread-1.dll} bin/ touch bin/data/put_your_rom_here.txt - name: Upload artifact uses: actions/upload-artifact@v4 From 2c4d3e7768210d653309db08bca6884df3b744ae Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 05:02:27 +0800 Subject: [PATCH 45/81] portx64: fixed linux build --- port/src/preprocess/common.h | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/port/src/preprocess/common.h b/port/src/preprocess/common.h index b75c6517f..4d2e6715d 100644 --- a/port/src/preprocess/common.h +++ b/port/src/preprocess/common.h @@ -6,11 +6,19 @@ #include #include +#ifdef PLATFORM_WIN32 + #include // this BS comes from windows.h #undef near #undef far +#else + +#include + +#endif + #include #include From cec92dbcb66e451157618a64a85082e24023219a Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 05:07:09 +0800 Subject: [PATCH 46/81] portx64: fixed linux build ops --- port/src/preprocess/common.h | 1 + 1 file changed, 1 insertion(+) diff --git a/port/src/preprocess/common.h b/port/src/preprocess/common.h index 4d2e6715d..3d6aa1671 100644 --- a/port/src/preprocess/common.h +++ b/port/src/preprocess/common.h @@ -5,6 +5,7 @@ #include #include #include +#include "platform.h" #ifdef PLATFORM_WIN32 From 40cc42a9410922a2e480454db0b98bce4261753f Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 21:49:10 +0800 Subject: [PATCH 47/81] portx64: fixed linux build, one more time --- include/PR/gbi.h | 1 + port/src/preprocess/filesetup.c | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/include/PR/gbi.h b/include/PR/gbi.h index c970c3997..84bbad552 100644 --- a/include/PR/gbi.h +++ b/include/PR/gbi.h @@ -22,6 +22,7 @@ #include #include "gbiex.h" +#include #ifndef PLATFORM_N64 #include "platform.h" diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index 3e22a71d0..b629e511b 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -20,7 +20,7 @@ static inline void convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } static inline void convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } static inline void cpyByte(u8 *dst, u8 src) { *dst = src; } static inline void convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } -static u32 convUnk(void* x, u32 y) { __debugbreak(); } +static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } #define PD_CONV_VAL(dst, src) _Generic((dst), \ f32: convF32, \ From a721349cff3b97855fc0981be1b4305061176638 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 21:55:39 +0800 Subject: [PATCH 48/81] portx64: fixed linux build, one more time --- port/src/preprocess/filesetup.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index b629e511b..10ec0bfcf 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -20,7 +20,7 @@ static inline void convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } static inline void convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } static inline void cpyByte(u8 *dst, u8 src) { *dst = src; } static inline void convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } -static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } +static inline void convUnk(u32 x) { assert(0 && "unknown type"); } #define PD_CONV_VAL(dst, src) _Generic((dst), \ f32: convF32, \ From e77b3172ed8e04b6ae7d428ee2aaeeec161649e5 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 9 Aug 2024 03:57:01 +0800 Subject: [PATCH 49/81] portx64: a bunch of gcc14 fixes portx64: fixed pal Update c-cpp.yml portx64: fixed linux build portx64: fixed linux build ops portx64: fixed linux build, one more time portx64: fixed linux build, one more time --- .github/workflows/c-cpp.yml | 2 +- include/PR/gbi.h | 1 + port/src/preprocess/common.h | 10 ++++ port/src/preprocess/filemodel.c | 43 ++++++++------- port/src/preprocess/filesetup.c | 97 ++++++++++++++++----------------- port/src/preprocess/segfonts.c | 2 +- port/src/preprocess/util_gbi.c | 2 +- src/game/file.c | 2 +- src/game/lang.c | 2 +- src/game/menuitem.c | 2 +- 10 files changed, 87 insertions(+), 76 deletions(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 6b2b689b8..8c5d673f5 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -40,7 +40,7 @@ jobs: cp build/ntsc-final-port/pd.exe bin/ cp build/pal-final-port/pd.pal.exe bin/ cp build/jpn-final-port/pd.jpn.exe bin/ - cp /mingw64/bin/{SDL2.dll,zlib1.dll,libgcc_s_dw2-1.dll,libwinpthread-1.dll} bin/ + cp /mingw64/bin/{SDL2.dll,zlib1.dll,libwinpthread-1.dll} bin/ touch bin/data/put_your_rom_here.txt - name: Upload artifact uses: actions/upload-artifact@v4 diff --git a/include/PR/gbi.h b/include/PR/gbi.h index c970c3997..84bbad552 100644 --- a/include/PR/gbi.h +++ b/include/PR/gbi.h @@ -22,6 +22,7 @@ #include #include "gbiex.h" +#include #ifndef PLATFORM_N64 #include "platform.h" diff --git a/port/src/preprocess/common.h b/port/src/preprocess/common.h index 0f9930d94..3d6aa1671 100644 --- a/port/src/preprocess/common.h +++ b/port/src/preprocess/common.h @@ -4,12 +4,22 @@ #include #include #include +#include +#include "platform.h" + +#ifdef PLATFORM_WIN32 #include // this BS comes from windows.h #undef near #undef far +#else + +#include + +#endif + #include #include diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index 5edece56e..79aa8a9f7 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -315,11 +315,11 @@ struct dst_texconfig { u8 unk0b; }; -static inline void *minPtr(void *a, void *b) { +static inline uintptr_t minPtr(uintptr_t a, uintptr_t b) { return (a && (a < b || !b)) ? a : b; } -static inline void *minPtr3(void *a, void *b, void *c) { +static inline uintptr_t minPtr3(uintptr_t a, uintptr_t b, uintptr_t c) { return minPtr(minPtr(a, b), c); } @@ -781,14 +781,14 @@ static u32 resolvePointer(u32 src_offset) static u8 *relinkPointers(u8 *dst, u8 *src) { - u8 *textures_end = 0; + uintptr_t textures_end = 0; for (int i = 0; i < m_NumMarkers; i++) { struct marker *marker = &m_Markers[i]; void *src_thing = &src[marker->src_offset]; void *dst_thing = &dst[marker->dst_offset]; - u8 *lowestptr = 0; + uintptr_t lowestptr = 0; switch (marker->type) { case CT_MODELDEF: @@ -913,6 +913,7 @@ static u8 *relinkPointers(u8 *dst, u8 *src) break; case CT_TEXDATA: case CT_VTXCOL: + case CT_VTXCOL4: case CT_GDL: case CT_RODATA_BBOX: case CT_RODATA_11: @@ -925,31 +926,17 @@ static u8 *relinkPointers(u8 *dst, u8 *src) textures_end = minPtr(textures_end, lowestptr); } - return textures_end; + return (u8*)textures_end; } -static int convertModel(u8 *dst, u8 *src, u32 srclen) -{ - u32 dstpos; - - populateMarkers(src); - sortMarkers(); - - dstpos = convertContent(dst, src, srclen); - u8 *tex_end = relinkPointers(dst, src); - preprocessModelTextures(dst, tex_end); - - return dstpos; -} - -void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) +static void preprocessTextureRGBA32Embedded(u32* dest, u32 size_bytes) { for (uint32_t i = 0; i < size_bytes; i += 4, ++dest) { *dest = PD_BE32(*dest); } } -void preprocessModelTextures(u8 *base, u8 *textures_end) +static void preprocessModelTextures(u8 *base, u8 *textures_end) { struct modeldef* mdl = (struct modeldef*)base; if (!mdl->texconfigs) return; @@ -976,6 +963,20 @@ void preprocessModelTextures(u8 *base, u8 *textures_end) } } +static int convertModel(u8* dst, u8* src, u32 srclen) +{ + u32 dstpos; + + populateMarkers(src); + sortMarkers(); + + dstpos = convertContent(dst, src, srclen); + u8* tex_end = relinkPointers(dst, src); + preprocessModelTextures(dst, tex_end); + + return dstpos; +} + u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize) { gbiReset(); diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index 2c4e8e977..10ec0bfcf 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -20,7 +20,7 @@ static inline void convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } static inline void convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } static inline void cpyByte(u8 *dst, u8 src) { *dst = src; } static inline void convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } -static u32 convUnk(void* x, u32 y) { __debugbreak(); } +static inline void convUnk(u32 x) { assert(0 && "unknown type"); } #define PD_CONV_VAL(dst, src) _Generic((dst), \ f32: convF32, \ @@ -40,7 +40,7 @@ static u32 convUnk(void* x, u32 y) { __debugbreak(); } for (int j = 0; j < ARRAYCOUNT(dst); j++) PD_CONV_VAL(dst[i][j], src[i][j]); \ } -#define PD_CONV_PTR(dst, src) dst = srctoh32(src) +#define PD_CONV_PTR(dst, src, type) dst = (type)srctoh32(src) static u32 obj_size(struct n64_defaultobj *obj) { @@ -109,10 +109,10 @@ static u32 obj_size(struct n64_defaultobj *obj) void conv_tvscreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) { - PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist); + PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist, u32*); PD_CONV_VAL(dstobj->offset, srcobj->offset); PD_CONV_VAL(dstobj->pause60, srcobj->pause60); - PD_CONV_PTR(dstobj->tconfig, srcobj->ptr_tconfig); + PD_CONV_PTR(dstobj->tconfig, srcobj->ptr_tconfig, struct textureconfig*); PD_CONV_VAL(dstobj->rot, srcobj->rot); PD_CONV_VAL(dstobj->xscale, srcobj->xscale); PD_CONV_VAL(dstobj->xscalefrac, srcobj->xscalefrac); @@ -180,12 +180,11 @@ void convertDefaultObj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) PD_CONV_VAL(dstobj->flags, srcobj->flags); PD_CONV_VAL(dstobj->flags2, srcobj->flags2); PD_CONV_VAL(dstobj->flags3, srcobj->flags3); - PD_CONV_PTR(dstobj->prop, srcobj->ptr_prop); - PD_CONV_PTR(dstobj->model, srcobj->ptr_model); + PD_CONV_PTR(dstobj->prop, srcobj->ptr_prop, struct prop*); + PD_CONV_PTR(dstobj->model, srcobj->ptr_model, struct model*); PD_CONV_ARRAY2D(dstobj->realrot, srcobj->realrot); PD_CONV_VAL(dstobj->hidden, srcobj->hidden); - PD_CONV_PTR(dstobj->unkgeo, srcobj->ptr_unkgeo); - PD_CONV_PTR(dstobj->embedment, srcobj->ptr_embedment); + PD_CONV_PTR(dstobj->unkgeo, srcobj->ptr_unkgeo, struct geocyl*); PD_CONV_VAL(dstobj->damage, srcobj->damage); PD_CONV_VAL(dstobj->maxdamage, srcobj->maxdamage); PD_CONV_ARRAY(dstobj->shadecol, srcobj->shadecol); @@ -230,7 +229,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->opadist, srcobj->opadist); PD_CONV_VAL(dstobj->startpos, srcobj->startpos); PD_CONV_ARRAY2D(dstobj->mtx98, srcobj->mtx98); - PD_CONV_PTR(dstobj->sibling, srcobj->ptr_sibling); + PD_CONV_PTR(dstobj->sibling, srcobj->ptr_sibling, struct doorobj*); PD_CONV_VAL(dstobj->lastopen60, srcobj->lastopen60); PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); @@ -337,7 +336,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->team, srcobj->team); - PD_CONV_PTR(dstobj->dualweapon, srcobj->ptr_dualweapon); + PD_CONV_PTR(dstobj->dualweapon, srcobj->ptr_dualweapon, struct weaponobj*); dst += sizeof(struct weaponobj); break; @@ -428,9 +427,9 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->lastseebond60, srcobj->lastseebond60); PD_CONV_VAL(dstobj->lastaimbond60, srcobj->lastaimbond60); PD_CONV_VAL(dstobj->allowsoundframe, srcobj->allowsoundframe); - PD_CONV_PTR(dstobj->beam, srcobj->ptr_beam); + PD_CONV_PTR(dstobj->beam, srcobj->ptr_beam, struct beam*); PD_CONV_VAL(dstobj->shotbondsum, srcobj->shotbondsum); - PD_CONV_PTR(dstobj->target, srcobj->ptr_target); + PD_CONV_PTR(dstobj->target, srcobj->ptr_target, struct prop*); PD_CONV_VAL(dstobj->targetteam, srcobj->targetteam); PD_CONV_VAL(dstobj->ammoquantity, srcobj->ammoquantity); PD_CONV_VAL(dstobj->nextchrtest, srcobj->nextchrtest); @@ -468,9 +467,9 @@ u32 convertProps(u8* dst, u8* src) struct linkliftdoorobj* dstobj = (struct linkliftdoorobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->lift, srcobj->ptr_lift); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door, struct prop*); + PD_CONV_PTR(dstobj->lift, srcobj->ptr_lift, struct prop*); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct linkliftdoorobj*); PD_CONV_VAL(dstobj->stopnum, srcobj->stopnum); dst += sizeof(struct linkliftdoorobj); @@ -513,8 +512,8 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->tagnum, srcobj->tagnum); PD_CONV_VAL(dstobj->cmdoffset, srcobj->cmdoffset); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct tag*); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj, struct defaultobj*); dst += sizeof(struct tag); break; @@ -572,7 +571,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->obj, srcobj->obj); PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct criteria_holograph*); dst += sizeof(struct criteria_holograph); break; @@ -585,7 +584,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->pad, srcobj->pad); PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct criteria_roomentered*); dst += sizeof(struct criteria_roomentered); break; @@ -598,7 +597,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->pad, srcobj->pad); PD_CONV_VAL(dstobj->status, srcobj->status); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct criteria_throwinroom*); dst += sizeof(struct criteria_throwinroom); break; @@ -611,7 +610,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); PD_CONV_VAL(dstobj->type, srcobj->type); PD_CONV_VAL(dstobj->text, srcobj->text); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct briefingobj*); dst += sizeof(struct briefingobj); break; @@ -629,8 +628,8 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->inventorytext, srcobj->inventorytext); PD_CONV_VAL(dstobj->inventory2text, srcobj->inventory2text); PD_CONV_VAL(dstobj->pickuptext, srcobj->pickuptext); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); - PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct textoverride*); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj, struct defaultobj*); dst += sizeof(struct textoverride); break; @@ -641,9 +640,9 @@ u32 convertProps(u8* dst, u8* src) struct padlockeddoorobj* dstobj = (struct padlockeddoorobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->lock, srcobj->ptr_lock); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door, struct doorobj*); + PD_CONV_PTR(dstobj->lock, srcobj->ptr_lock, struct defaultobj*); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct padlockeddoorobj*); dst += sizeof(struct padlockeddoorobj); break; @@ -655,7 +654,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist, u8*); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -665,7 +664,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); PD_CONV_VAL(dstobj->roty, srcobj->roty); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path, struct path*); PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); dst += sizeof(struct truckobj); @@ -678,7 +677,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist, u8*); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->rotoryrot, srcobj->rotoryrot); @@ -689,7 +688,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); PD_CONV_VAL(dstobj->yrot, srcobj->yrot); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path, struct path*); PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); dst += sizeof(struct heliobj); @@ -712,10 +711,10 @@ u32 convertProps(u8* dst, u8* src) struct safeitemobj* dstobj = (struct safeitemobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->item, srcobj->ptr_item); - PD_CONV_PTR(dstobj->safe, srcobj->ptr_safe); - PD_CONV_PTR(dstobj->door, srcobj->ptr_door); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->item, srcobj->ptr_item, struct defaultobj*); + PD_CONV_PTR(dstobj->safe, srcobj->ptr_safe, struct safeobj*); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door, struct doorobj*); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct safeitemobj*); dst += sizeof(struct safeitemobj); break; @@ -766,7 +765,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_ARRAY(dstobj->pads, srcobj->pads); for (int k = 0; k < 4; k++) - PD_CONV_PTR(dstobj->doors[k], srcobj->ptr_doors[k]); + PD_CONV_PTR(dstobj->doors[k], srcobj->ptr_doors[k], struct doorobj*); PD_CONV_VAL(dstobj->dist, srcobj->dist); PD_CONV_VAL(dstobj->speed, srcobj->speed); PD_CONV_VAL(dstobj->accel, srcobj->accel); @@ -785,10 +784,10 @@ u32 convertProps(u8* dst, u8* src) struct linksceneryobj* dstobj = (struct linksceneryobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->trigger, srcobj->ptr_trigger); - PD_CONV_PTR(dstobj->unexp, srcobj->ptr_unexp); - PD_CONV_PTR(dstobj->exp, srcobj->ptr_exp); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->trigger, srcobj->ptr_trigger, struct defaultobj*); + PD_CONV_PTR(dstobj->unexp, srcobj->ptr_unexp, struct defaultobj*); + PD_CONV_PTR(dstobj->exp, srcobj->ptr_exp, struct defaultobj*); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct linksceneryobj*); dst += sizeof(struct linksceneryobj); break; @@ -799,10 +798,10 @@ u32 convertProps(u8* dst, u8* src) struct blockedpathobj* dstobj = (struct blockedpathobj*)dst; convertDefaultObjHdr((struct defaultobj*)dstobj, cmd); - PD_CONV_PTR(dstobj->blocker, srcobj->ptr_blocker); + PD_CONV_PTR(dstobj->blocker, srcobj->ptr_blocker, struct defaultobj*); PD_CONV_VAL(dstobj->waypoint1, srcobj->waypoint1); PD_CONV_VAL(dstobj->waypoint2, srcobj->waypoint2); - PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next, struct blockedpathobj*); dst += sizeof(struct blockedpathobj); break; @@ -898,7 +897,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist, u8*); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -910,7 +909,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->roty, srcobj->roty); PD_CONV_VAL(dstobj->rotx, srcobj->rotx); PD_CONV_VAL(dstobj->rotz, srcobj->rotz); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path, struct path*); PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); PD_CONV_VAL(dstobj->status, srcobj->status); PD_CONV_VAL(dstobj->dead, srcobj->dead); @@ -939,7 +938,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); - PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist); + PD_CONV_PTR(dstobj->ailist, srcobj->ptr_ailist, u8*); PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); PD_CONV_VAL(dstobj->speed, srcobj->speed); @@ -951,7 +950,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->roty, srcobj->roty); PD_CONV_VAL(dstobj->rotx, srcobj->rotx); PD_CONV_VAL(dstobj->rotz, srcobj->rotz); - PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path, struct path*); PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); PD_CONV_VAL(dstobj->weaponsarmed, srcobj->weaponsarmed); PD_CONV_VAL(dstobj->ontarget, srcobj->ontarget); @@ -976,7 +975,7 @@ u32 convertProps(u8* dst, u8* src) PD_CONV_VAL(dstobj->gunrotx, srcobj->gunrotx); PD_CONV_VAL(dstobj->barrelrotspeed, srcobj->barrelrotspeed); PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); - PD_CONV_PTR(dstobj->fireslotthing, srcobj->ptr_fireslotthing); + PD_CONV_PTR(dstobj->fireslotthing, srcobj->ptr_fireslotthing, struct fireslotthing*); PD_CONV_VAL(dstobj->dead, srcobj->dead); dst += sizeof(struct chopperobj); @@ -1050,7 +1049,7 @@ static u32 convertPaths(u8 *dst, u8 *src) struct path* dstpath = (struct path*)dst; while (true) { - PD_CONV_PTR(dstpath->pads, srcpath->ptr_pads); + PD_CONV_PTR(dstpath->pads, srcpath->ptr_pads, s32*); PD_CONV_VAL(dstpath->id, srcpath->id); PD_CONV_VAL(dstpath->flags, srcpath->flags); PD_CONV_VAL(dstpath->len, srcpath->len); @@ -1093,7 +1092,7 @@ static u32 convertAiLists(u8* dst, u8* src) while (true) { // at this point these fields are already converted, so we just assign - dstailist->list = srcailist->ptr_list; + dstailist->list = (u8*)srcailist->ptr_list; dstailist->id = srcailist->id; @@ -1123,7 +1122,7 @@ static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) for (struct n64_ailist *ailist = src_ailists; ailist->ptr_list; ailist++) { // update the src list pointers here uintptr_t src_ptr_list = (uintptr_t) ailist->ptr_list; - ailist->ptr_list = (u8*)dstpos; + ailist->ptr_list = dstpos; // multiple ailists can point to the same list, so we need to check if it was already copied struct ptrmarker *marker = findPtrMarker(src_ptr_list); diff --git a/port/src/preprocess/segfonts.c b/port/src/preprocess/segfonts.c index b2f9ab1b8..e201d21ee 100644 --- a/port/src/preprocess/segfonts.c +++ b/port/src/preprocess/segfonts.c @@ -59,7 +59,7 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) if (src == _fonthandelgothicsmSegmentRomStart || src == _fonthandelgothicxsSegmentRomStart || src == _fonthandelgothicmdSegmentRomStart) { - numchars = 135; + num_chars = 135; } #endif diff --git a/port/src/preprocess/util_gbi.c b/port/src/preprocess/util_gbi.c index 75b4a621a..680d22e75 100644 --- a/port/src/preprocess/util_gbi.c +++ b/port/src/preprocess/util_gbi.c @@ -151,7 +151,7 @@ void gbiGdlRewriteAddrs(u8 *dst, u32 offset) do { cmd = *cmds; - Gfx* gfxcmd = cmds; + Gfx* gfxcmd = (Gfx *)cmds; int idx = 0; u8 opcode = (cmd >> 24) & 0xff; diff --git a/src/game/file.c b/src/game/file.c index 6c188338c..825ebf7c1 100644 --- a/src/game/file.c +++ b/src/game/file.c @@ -4259,7 +4259,7 @@ u32 fileGetInflatedSize(s32 filenum, FileType filetype) { u8 *ptr; u8 buffer[0x50]; - u32 *romaddrptr; + uintptr_t *romaddrptr; #if VERSION < VERSION_NTSC_1_0 char message[128]; #endif diff --git a/src/game/lang.c b/src/game/lang.c index bd97e6c1f..65565b496 100644 --- a/src/game/lang.c +++ b/src/game/lang.c @@ -377,7 +377,7 @@ s32 langGetFileId(s32 bank) void langLoad(s32 bank) { #if VERSION >= VERSION_PAL_BETA - s32 len = fileGetInflatedSize(langGetFileId(bank)); + s32 len = fileGetInflatedSize(langGetFileId(bank), LOADTYPE_LANG); if ((uintptr_t)g_LangBuffer + len + g_LangBufferSize - (uintptr_t)g_LangBufferPos >= 0) { s32 len2 = (uintptr_t)g_LangBuffer + g_LangBufferSize - (uintptr_t)g_LangBufferPos; diff --git a/src/game/menuitem.c b/src/game/menuitem.c index f456bfe27..c95acb89e 100644 --- a/src/game/menuitem.c +++ b/src/game/menuitem.c @@ -799,7 +799,7 @@ bool menuitemListTick(struct menuitem *item, struct menuinputs *inputs, u32 tick void menuitemDropdownInit(struct menuitem *item, union menuitemdata *data) { - s32 (*handler)(s32 operation, struct menuitem *item, union handlerdata *data); + uintptr_t (*handler)(s32 operation, struct menuitem *item, union handlerdata *data); union handlerdata handlerdata; union handlerdata handlerdata2; From 2fd1c49ef5ded49de1669c7ac0e2ce1f7288f0f1 Mon Sep 17 00:00:00 2001 From: Raf Date: Sat, 10 Aug 2024 01:14:06 +0800 Subject: [PATCH 50/81] Update c-cpp.yml --- .github/workflows/c-cpp.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 8c5d673f5..6054c4424 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -56,7 +56,7 @@ jobs: run: | sudo dpkg --add-architecture amd64 sudo apt-get update - sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-dev zlib1g-dev + sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-dev:i386 zlib1g-dev:i386 - name: Checkout repository uses: actions/checkout@v4 - name: Build pd.exe From 4b44b5b4e35349977f10e3cdab0b2ef8523f5fdb Mon Sep 17 00:00:00 2001 From: Raf Date: Sat, 10 Aug 2024 01:18:49 +0800 Subject: [PATCH 51/81] Update c-cpp.yml --- .github/workflows/c-cpp.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 6054c4424..f6d76edb9 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -56,7 +56,7 @@ jobs: run: | sudo dpkg --add-architecture amd64 sudo apt-get update - sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-dev:i386 zlib1g-dev:i386 + sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-2.0-0: - name: Checkout repository uses: actions/checkout@v4 - name: Build pd.exe From 6a5d249e67325940c048abf4a0d78c286985d001 Mon Sep 17 00:00:00 2001 From: Raf Date: Sat, 10 Aug 2024 02:21:07 +0800 Subject: [PATCH 52/81] Update c-cpp.yml --- .github/workflows/c-cpp.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index f6d76edb9..929ca2b06 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -56,7 +56,7 @@ jobs: run: | sudo dpkg --add-architecture amd64 sudo apt-get update - sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-2.0-0: + sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-2.0-0 - name: Checkout repository uses: actions/checkout@v4 - name: Build pd.exe From ae2543de90b026bfa4d6b423db0d8710c8ff3f8a Mon Sep 17 00:00:00 2001 From: Raf Date: Sat, 10 Aug 2024 17:19:56 +0800 Subject: [PATCH 53/81] Update c-cpp.yml: fixed arch prefix (x86_64) everywhere --- .github/workflows/c-cpp.yml | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 929ca2b06..b36f92678 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -8,7 +8,7 @@ on: workflow_dispatch: jobs: - build-i686-windows: + build-x86_64-windows: runs-on: windows-latest defaults: run: @@ -45,11 +45,11 @@ jobs: - name: Upload artifact uses: actions/upload-artifact@v4 with: - name: pd-i686-windows-x64 + name: pd-x86_64-windows path: bin/ retention-days: 0 - build-i686-linux: + build-x86_64-linux: runs-on: ubuntu-latest steps: - name: Install dependencies @@ -60,11 +60,11 @@ jobs: - name: Checkout repository uses: actions/checkout@v4 - name: Build pd.exe - run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 + run: make -f Makefile.port TARGET_PLATFORM=x86_64-linux -j2 - name: Build pd.pal.exe - run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 ROMID=pal-final + run: make -f Makefile.port TARGET_PLATFORM=x86_64-linux -j2 ROMID=pal-final - name: Build pd.jpn.exe - run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 ROMID=jpn-final + run: make -f Makefile.port TARGET_PLATFORM=x86_64-linux -j2 ROMID=jpn-final - name: Prepare artifact for packaging run: | mkdir -p bin/data @@ -75,14 +75,14 @@ jobs: - name: Upload artifact uses: actions/upload-artifact@v4 with: - name: pd-i686-linux-x64 + name: pd-x86_64-linux path: bin/ retention-days: 0 publish-latest-build: runs-on: ubuntu-latest if: github.ref == 'refs/heads/port-x64' - needs: [build-i686-windows, build-i686-linux] + needs: [build-x86_64-windows, build-x86_64-linux] permissions: contents: write steps: @@ -96,8 +96,8 @@ jobs: run: | mkdir ci-release pushd ci-artifacts - tar czf ../ci-release/pd-i686-linux-x64.tar.gz pd-i686-linux-x64 - zip -r ../ci-release/pd-i686-windows-x64.zip pd-i686-windows-x64 + tar czf ../ci-release/pd-x86_64-linux.tar.gz pd-x86_64-linux + zip -r ../ci-release/pd-x86_64-windows.zip pd-x86_64-windows popd git tag --force ci-dev-build-x64 port git push --force origin ci-dev-build-x64 From 8be982fdb65d531e84829a75910c610f82e99dfa Mon Sep 17 00:00:00 2001 From: Raf Date: Sat, 10 Aug 2024 17:31:41 +0800 Subject: [PATCH 54/81] Update c-cpp.yml --- .github/workflows/c-cpp.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index b36f92678..e4f48a1e5 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -99,6 +99,6 @@ jobs: tar czf ../ci-release/pd-x86_64-linux.tar.gz pd-x86_64-linux zip -r ../ci-release/pd-x86_64-windows.zip pd-x86_64-windows popd - git tag --force ci-dev-build-x64 port + git tag --force ci-dev-build-x64 port-x64 git push --force origin ci-dev-build-x64 gh release upload --clobber ci-dev-build-x64 ci-release/* From ab514f39af7a9f970cfebdafd82a90edfa741eeb Mon Sep 17 00:00:00 2001 From: Raf Date: Sat, 10 Aug 2024 20:27:29 +0800 Subject: [PATCH 55/81] Update c-cpp.yml added missing dll: libgcc_s_seh-1.dll --- .github/workflows/c-cpp.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index e4f48a1e5..f450aa87c 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -40,7 +40,7 @@ jobs: cp build/ntsc-final-port/pd.exe bin/ cp build/pal-final-port/pd.pal.exe bin/ cp build/jpn-final-port/pd.jpn.exe bin/ - cp /mingw64/bin/{SDL2.dll,zlib1.dll,libwinpthread-1.dll} bin/ + cp /mingw64/bin/{SDL2.dll,zlib1.dll,libwinpthread-1.dll,libgcc_s_seh-1.dll} bin/ touch bin/data/put_your_rom_here.txt - name: Upload artifact uses: actions/upload-artifact@v4 From 3524ec73b71663eab08350e0b9c2a4e1af9e8b5f Mon Sep 17 00:00:00 2001 From: Raf <> Date: Mon, 12 Aug 2024 16:32:49 +0800 Subject: [PATCH 56/81] portx64: fixes #1 - muzzle flashes broken on some weapons --- port/src/preprocess/filemodel.c | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index 79aa8a9f7..9a0c6261f 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -33,6 +33,7 @@ enum contenttype { /*19*/ CT_RODATA_DL, /*20*/ CT_RODATA_19, /*21*/ CT_VTXCOL4, // CT_VTXCOL but aligned to 4 bytes instead of 8 + /*22*/ CT_SKIP, // to skip padding data }; struct marker { @@ -70,6 +71,7 @@ struct alignconfig m_AlignConfigs[] = { /*19*/ { 8, 4 }, // CT_RODATA_DL /*20*/ { 4, 4 }, /*21*/ { 4, 4 }, + /*22*/ { 4, 4 } }; struct marker m_Markers[1024]; @@ -463,12 +465,15 @@ static void populateMarkers(u8 *src) break; case CT_RODATA_STARGUNFIRE: struct src_rodata_stargunfire *src_stargunfire = src_thing; - colstart = srctoh32(src_stargunfire->unk00)*4*12; + colstart = srctoh32(src_stargunfire->unk00)*4*(sizeof(s16) * 6); u32 vtxstart = srctoh32(src_stargunfire->ptr_vertices); - colstart = ALIGN(vtxstart + colstart, 8); - - set_marker(srctoh32(src_stargunfire->ptr_vertices), CT_VTXCOL4, marker->src_offset); - set_marker(colstart, CT_VTXCOL4, marker->src_offset); + u32 vtxend = vtxstart + colstart; + colstart = ALIGN8(vtxstart + colstart); + set_marker(vtxstart, CT_VTXCOL4, marker->src_offset); + if (vtxend != colstart) { + set_marker(vtxend, CT_SKIP, marker->src_offset); + } + set_marker(colstart, CT_VTXCOL, marker->src_offset); set_marker(srctoh32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); break; case CT_RODATA_DL: @@ -761,6 +766,8 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) dstpos += sizeof(u32) * 3; } break; + case CT_SKIP: + break; } dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].after); From 589bdf1cd9c18eb520385c27c5172066d50c27e2 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Mon, 12 Aug 2024 16:33:55 +0800 Subject: [PATCH 57/81] portx64: fixes #2 - hoverbike not carrying over to crash-site --- port/src/preprocess/filepads.c | 1 - 1 file changed, 1 deletion(-) diff --git a/port/src/preprocess/filepads.c b/port/src/preprocess/filepads.c index f1f42ee52..25e9ccf5e 100644 --- a/port/src/preprocess/filepads.c +++ b/port/src/preprocess/filepads.c @@ -80,7 +80,6 @@ static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) dstpos += num_pads * sizeof(u16); for (int i = 0; i < num_pads; i++) { - dstpos = ALIGN4(dstpos); srcpos = srctoh16(src_offsets[i]); dst_offsets[i] = htodst16(dstpos); From 077cc67b7984d66e5597f7faf29007cc31f3af79 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Mon, 12 Aug 2024 16:35:20 +0800 Subject: [PATCH 58/81] portx64: fixes #3 - some weapons stuck after switching to 1st function Tested in 32-bit as well --- src/include/types.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/types.h b/src/include/types.h index bfc30039a..d0242c01f 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -5367,7 +5367,7 @@ struct guncmd { u8 type; u8 unk01; u16 unk02; - uintptr_t unk04; + intptr_t unk04; }; struct pakthing { From 5841fb9afa58a205abd0926ab2839ce8e3200453 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Mon, 12 Aug 2024 18:56:49 +0800 Subject: [PATCH 59/81] portx64: fixes #4 - jpn/pal versions crashing on startup --- src/game/lang.c | 2 +- src/game/langreset.c | 5 +++++ src/game/utils.c | 4 ++-- src/include/game/utils.h | 2 +- 4 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/game/lang.c b/src/game/lang.c index 65565b496..f7d61f336 100644 --- a/src/game/lang.c +++ b/src/game/lang.c @@ -377,7 +377,7 @@ s32 langGetFileId(s32 bank) void langLoad(s32 bank) { #if VERSION >= VERSION_PAL_BETA - s32 len = fileGetInflatedSize(langGetFileId(bank), LOADTYPE_LANG); + s32 len = fileGetInflatedSize(langGetFileId(bank), FT_LANG); if ((uintptr_t)g_LangBuffer + len + g_LangBufferSize - (uintptr_t)g_LangBufferPos >= 0) { s32 len2 = (uintptr_t)g_LangBuffer + g_LangBufferSize - (uintptr_t)g_LangBufferPos; diff --git a/src/game/langreset.c b/src/game/langreset.c index 0f64e8cec..a85afd8dd 100644 --- a/src/game/langreset.c +++ b/src/game/langreset.c @@ -6,6 +6,7 @@ #include "lib/memp.h" #include "data.h" #include "types.h" +#include "platform.h" extern u8 *g_LangBuffer; extern s32 g_LangBufferSize; @@ -45,6 +46,10 @@ void langReset(s32 stagenum) } } +#ifdef PLATFORM_64BIT + size *= 2; +#endif + g_LangBuffer = mempAlloc(ALIGN16(size), MEMPOOL_STAGE); g_LangBufferSize = size; diff --git a/src/game/utils.c b/src/game/utils.c index 0432870f4..fa00c2e0e 100644 --- a/src/game/utils.c +++ b/src/game/utils.c @@ -69,10 +69,10 @@ u32 align16(u32 arg0) return arg0; } -u32 align32(u32 arg0) +uintptr_t align32(uintptr_t arg0) { if (arg0 & 0x1f) { - arg0 = (arg0 & 0xffffffe0) + 0x20; + arg0 = (arg0 & ((intptr_t)~0x1f)) + 0x20; } return arg0; diff --git a/src/include/game/utils.h b/src/include/game/utils.h index 5e992a212..83ada1f98 100644 --- a/src/include/game/utils.h +++ b/src/include/game/utils.h @@ -7,7 +7,7 @@ void func0f176d70(s32 arg0); u32 align4(u32 arg0); u32 align16(u32 arg0); -u32 align32(u32 arg0); +uintptr_t align32(uintptr_t arg0); void utilsInit(void); void func0f1770ac(struct coord *a, struct coord *b, struct coord *out); bool func0f177164(struct coord *arg0, struct coord *arg1, u32 line, char *file); From eabbdc612c41a263bb04d0c7575813e01ce486e4 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Mon, 12 Aug 2024 21:08:04 +0800 Subject: [PATCH 60/81] portx64: fixes #5 - crossbow bolt beams not rendering correctly --- src/include/types.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/types.h b/src/include/types.h index d0242c01f..da5d058b4 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -5235,7 +5235,7 @@ struct mplockinfo { struct boltbeam { union { - s32 unk00; + intptr_t unk00; struct prop *unk00_prop; }; From 8533189561f0ced364c5b11c69b3b4ecc0a06d8d Mon Sep 17 00:00:00 2001 From: Raf <> Date: Mon, 12 Aug 2024 21:20:30 +0800 Subject: [PATCH 61/81] portx64: include "platform.h" wherever the flag PLATFORM_64bit is used, to avoid possible nasty surprises --- include/PR/R4300.h | 1 + include/PR/n_libaudio.h | 1 + src/game/bg.c | 1 + src/game/bondgun.c | 1 + src/game/dlights.c | 1 + src/game/gfxmemory.c | 1 + src/game/menu.c | 1 + src/game/nbomb.c | 1 + src/game/player.c | 1 + src/game/setuppads.c | 1 + src/game/tex.c | 1 + src/game/texdecompress.c | 1 + src/lib/modelasm_c.c | 1 + src/lib/mp3.c | 1 + src/lib/mp3/mp3.h | 1 + src/lib/vi.c | 1 + 16 files changed, 16 insertions(+) diff --git a/include/PR/R4300.h b/include/PR/R4300.h index 061ed8158..d5212ec6a 100644 --- a/include/PR/R4300.h +++ b/include/PR/R4300.h @@ -22,6 +22,7 @@ #define __R4300_H__ #include +#include "platform.h" /* * Segment base addresses and sizes diff --git a/include/PR/n_libaudio.h b/include/PR/n_libaudio.h index 5a06e9558..d672986e8 100644 --- a/include/PR/n_libaudio.h +++ b/include/PR/n_libaudio.h @@ -28,6 +28,7 @@ extern "C" { #include #include +#include "platform.h" struct var8009c340 { u8 surround; diff --git a/src/game/bg.c b/src/game/bg.c index a3cd5047a..1ad070d12 100644 --- a/src/game/bg.c +++ b/src/game/bg.c @@ -47,6 +47,7 @@ #include "preprocess.h" #include "system.h" #include "video.h" +#include "platform.h" #endif #define BGCMD_END 0x00 diff --git a/src/game/bondgun.c b/src/game/bondgun.c index e3359415d..f82473f3a 100644 --- a/src/game/bondgun.c +++ b/src/game/bondgun.c @@ -56,6 +56,7 @@ #ifndef PLATFORM_N64 #include "game/stagetable.h" #include "video.h" +#include "platform.h" #endif #define GUNLOADSTATE_FLUX 0 diff --git a/src/game/dlights.c b/src/game/dlights.c index 2dd9af0fe..93d59f826 100644 --- a/src/game/dlights.c +++ b/src/game/dlights.c @@ -28,6 +28,7 @@ #include "lib/lib_317f0.h" #include "data.h" #include "types.h" +#include "platform.h" const char var7f1a78e0[] = "LIGHTS : Hit occured on light %d in room %d\n"; const char var7f1a7910[] = "L2(%d) -> "; diff --git a/src/game/gfxmemory.c b/src/game/gfxmemory.c index f105bce2c..79e61f9bd 100644 --- a/src/game/gfxmemory.c +++ b/src/game/gfxmemory.c @@ -11,6 +11,7 @@ #include "lib/str.h" #include "data.h" #include "types.h" +#include "platform.h" /** * This file handles memory usage for graphics related tasks. diff --git a/src/game/menu.c b/src/game/menu.c index 31ebba11c..8df5e4478 100644 --- a/src/game/menu.c +++ b/src/game/menu.c @@ -51,6 +51,7 @@ #ifndef PLATFORM_N64 #include "video.h" #include "input.h" +#include "platform.h" #define BLUR_OFS 10 #else #define BLUR_OFS 30 diff --git a/src/game/nbomb.c b/src/game/nbomb.c index e3e3dcb9d..d0e59433c 100644 --- a/src/game/nbomb.c +++ b/src/game/nbomb.c @@ -24,6 +24,7 @@ #include "lib/lib_317f0.h" #include "data.h" #include "types.h" +#include "platform.h" s16 var8009cb00; s32 var8009cb04; diff --git a/src/game/player.c b/src/game/player.c index 4c72eb226..4d2eb6389 100644 --- a/src/game/player.c +++ b/src/game/player.c @@ -73,6 +73,7 @@ #ifndef PLATFORM_N64 #include "video.h" #include "input.h" +#include "platform.h" #endif s32 g_DefaultWeapons[2]; diff --git a/src/game/setuppads.c b/src/game/setuppads.c index 241d31479..52a7cba11 100644 --- a/src/game/setuppads.c +++ b/src/game/setuppads.c @@ -11,6 +11,7 @@ #include "lib/model.h" #include "data.h" #include "types.h" +#include "platform.h" /** * The function assumes that a pad file's data has been loaded from the ROM diff --git a/src/game/tex.c b/src/game/tex.c index f63a00c23..f7d226b15 100644 --- a/src/game/tex.c +++ b/src/game/tex.c @@ -8,6 +8,7 @@ #include "gbiex.h" #include "textures.h" #include "types.h" +#include "platform.h" #define TXMODE_WRAP 0 #define TXMODE_CLAMP 1 diff --git a/src/game/texdecompress.c b/src/game/texdecompress.c index 1e39dc2f6..40e1e4a10 100644 --- a/src/game/texdecompress.c +++ b/src/game/texdecompress.c @@ -12,6 +12,7 @@ #include "types.h" #ifndef PLATFORM_N64 #include "mod.h" +#include "platform.h" #endif struct texture *g_Textures; diff --git a/src/lib/modelasm_c.c b/src/lib/modelasm_c.c index ea24e12c8..6570424bb 100644 --- a/src/lib/modelasm_c.c +++ b/src/lib/modelasm_c.c @@ -5,6 +5,7 @@ #include "lib/model.h" #include "lib/mtx.h" #include "types.h" +#include "platform.h" struct t0slot { u16 unk00; diff --git a/src/lib/mp3.c b/src/lib/mp3.c index e94af6431..1d20d9151 100644 --- a/src/lib/mp3.c +++ b/src/lib/mp3.c @@ -6,6 +6,7 @@ #include "lib/mp3.h" #include "mp3/mp3.h" #include "types.h" +#include "platform.h" /** * These two ABI commands are used in this file, but the format of the data diff --git a/src/lib/mp3/mp3.h b/src/lib/mp3/mp3.h index eab395a1c..96447a84b 100644 --- a/src/lib/mp3/mp3.h +++ b/src/lib/mp3/mp3.h @@ -2,6 +2,7 @@ #define _IN_LIB_MP3_MP3_H #include #include "types.h" +#include "platform.h" struct mp3decfourbytes { u8 bytes[2]; diff --git a/src/lib/vi.c b/src/lib/vi.c index 992264dcb..884ee8d19 100644 --- a/src/lib/vi.c +++ b/src/lib/vi.c @@ -16,6 +16,7 @@ #include "types.h" #ifndef PLATFORM_N64 #include "video.h" +#include "platform.h" #endif #define TO_U16_A(x) ((u16)(x)) From 19167b846818b91e18d5b6c71358e8c6ee1c459a Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 4 Oct 2024 00:13:36 +0800 Subject: [PATCH 62/81] portx64: added back 32-bit targets to CI --- .github/workflows/c-cpp.yml | 76 ++++++++++++++++++++++++++++++++++++- 1 file changed, 74 insertions(+), 2 deletions(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index a684cbf17..f75e022c6 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -8,6 +8,76 @@ on: workflow_dispatch: jobs: + build-i686-windows: + runs-on: windows-latest + defaults: + run: + shell: msys2 {0} + steps: + - name: Install MSYS2 + uses: msys2/setup-msys2@v2 + with: + msystem: MINGW32 + update: true + install: >- + git + make + mingw-w64-i686-toolchain + mingw-w64-i686-SDL2 + mingw-w64-i686-zlib + - name: Checkout repository + uses: actions/checkout@v4 + - name: Build pd.exe + run: make -f Makefile.port -j + - name: Build pd.pal.exe + run: make -f Makefile.port -j ROMID=pal-final + - name: Build pd.jpn.exe + run: make -f Makefile.port -j ROMID=jpn-final + - name: Prepare artifact for packaging + run: | + mkdir -p bin/data + cp build/ntsc-final-port/pd.exe bin/ + cp build/pal-final-port/pd.pal.exe bin/ + cp build/jpn-final-port/pd.jpn.exe bin/ + cp /mingw32/bin/{SDL2.dll,zlib1.dll,libgcc_s_dw2-1.dll,libwinpthread-1.dll} bin/ + touch bin/data/put_your_rom_here.txt + - name: Upload artifact + uses: actions/upload-artifact@v4 + with: + name: pd-i686-windows + path: bin/ + retention-days: 0 + + build-i686-linux: + runs-on: ubuntu-latest + steps: + - name: Install dependencies + run: | + sudo dpkg --add-architecture i386 + sudo apt-get update + sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-dev:i386 zlib1g-dev:i386 + - name: Checkout repository + uses: actions/checkout@v4 + - name: Build pd.exe + run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 + - name: Build pd.pal.exe + run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 ROMID=pal-final + - name: Build pd.jpn.exe + run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 ROMID=jpn-final + - name: Prepare artifact for packaging + run: | + mkdir -p bin/data + cp build/ntsc-final-port/pd.exe bin/pd + cp build/pal-final-port/pd.pal.exe bin/pd.pal + cp build/jpn-final-port/pd.jpn.exe bin/pd.jpn + touch bin/data/put_your_rom_here.txt + - name: Upload artifact + uses: actions/upload-artifact@v4 + with: + name: pd-i686-linux + path: bin/ + retention-days: 0 + build-x86_64-windows: runs-on: windows-latest defaults: @@ -82,7 +152,7 @@ jobs: build-flatpak-bundle: name: "Build flatpak bundle" runs-on: ubuntu-latest - needs: [build-x86_64-linux] + needs: [build-i686-linux, build-x86_64-linux] container: image: bilelmoussaoui/flatpak-github-actions:freedesktop-23.08 options: --privileged @@ -118,7 +188,7 @@ jobs: publish-latest-build: runs-on: ubuntu-latest if: github.ref == 'refs/heads/port-x64' - needs: [build-x86_64-windows, build-x86_64-linux, build-flatpak-bundle] + needs: [build-i686-windows, build-i686-linux, build-x86_64-windows, build-x86_64-linux, build-flatpak-bundle] permissions: contents: write steps: @@ -132,7 +202,9 @@ jobs: run: | mkdir ci-release pushd ci-artifacts + tar czf ../ci-release/pd-i686-linux.tar.gz pd-i686-linux tar czf ../ci-release/pd-x86_64-linux.tar.gz pd-x86_64-linux + zip -r ../ci-release/pd-i686-windows.zip pd-i686-windows zip -r ../ci-release/pd-x86_64-windows.zip pd-x86_64-windows mv io.github.fgsfdsfgs.perfect_dark.flatpak/io.github.fgsfdsfgs.perfect_dark.flatpak ../ci-release/ popd From f37abc941e4f58c2fdf0911514420a802a03cdfc Mon Sep 17 00:00:00 2001 From: fgsfds Date: Sun, 10 Nov 2024 10:41:15 +0100 Subject: [PATCH 63/81] port: 64-bit cleanup: remove dead preprocess code --- port/src/preprocess/common.c | 4 +- port/src/preprocess/preprocess.c | 132 ------------------------------- 2 files changed, 2 insertions(+), 134 deletions(-) diff --git a/port/src/preprocess/common.c b/port/src/preprocess/common.c index 542b9d8dc..774ff267d 100644 --- a/port/src/preprocess/common.c +++ b/port/src/preprocess/common.c @@ -1,8 +1,8 @@ #include "common.h" #include "system.h" -struct ptrmarker m_PtrMarkers[1024*8]; -int m_NumPtrMarkers; +static struct ptrmarker m_PtrMarkers[1024*8]; +static int m_NumPtrMarkers; void addMarker(u32 ptr_src, uintptr_t ptr_host) { diff --git a/port/src/preprocess/preprocess.c b/port/src/preprocess/preprocess.c index d27d398e8..dc544161b 100644 --- a/port/src/preprocess/preprocess.c +++ b/port/src/preprocess/preprocess.c @@ -4,7 +4,6 @@ #include #include #include -#include #include "platform.h" #include "data.h" #include "bss.h" @@ -16,121 +15,6 @@ #include "system.h" #include "common.h" -// HACK: to prevent double-swapping stuff, flag swapped offsets in a bitmap - -static u8 swapmap[0x40000 >> 3]; - -static inline u32 alreadySwapped(const intptr_t addr) { - const u32 mask = (1 << (addr & 7)); - const u32 old = swapmap[addr >> 3] & mask; - if (!old) { - swapmap[addr >> 3] |= mask; - } - return old; -} - -static inline void preprocessALWaveTable(ALWaveTable *tbl, u8 *bankBase) -{ - if (alreadySwapped((u8 *)tbl - bankBase)) { - return; - } - - PD_SWAP_VAL(tbl->len); - PD_SWAP_PTR(tbl->base); - - if (tbl->type == AL_ADPCM_WAVE) { - if (tbl->waveInfo.adpcmWave.loop ) { - PD_SWAP_PTR(tbl->waveInfo.adpcmWave.loop); - ALADPCMloop *loop = PD_PTR_BASE(tbl->waveInfo.adpcmWave.loop, bankBase); - PD_SWAP_VAL(loop->count); - PD_SWAP_VAL(loop->start); - PD_SWAP_VAL(loop->end); - for (s32 i = 0; i < 16; ++i) { - PD_SWAP_VAL(loop->state[i]); - } - } - if (tbl->waveInfo.adpcmWave.book) { - PD_SWAP_PTR(tbl->waveInfo.adpcmWave.book); - ALADPCMBook *book = PD_PTR_BASE(tbl->waveInfo.adpcmWave.book, bankBase); - PD_SWAP_VAL(book->npredictors); - PD_SWAP_VAL(book->order); - const s32 bookSize = book->order * book->npredictors * ADPCMVSIZE; - for (s32 i = 0; i < bookSize && i < 128; ++i) { - PD_SWAP_VAL(book->book[i]); - } - } - } else if (tbl->type == AL_RAW16_WAVE) { - if (tbl->waveInfo.rawWave.loop) { - PD_SWAP_PTR(tbl->waveInfo.rawWave.loop); - ALRawLoop *loop = PD_PTR_BASE(tbl->waveInfo.rawWave.loop, bankBase); - PD_SWAP_VAL(loop->count); - PD_SWAP_VAL(loop->start); - PD_SWAP_VAL(loop->end); - } - } -} - -static inline void preprocessALSound(ALSound *snd, u8 *bankBase) -{ - if (alreadySwapped((u8 *)snd - bankBase)) { - return; - } - - if (snd->envelope) { - PD_SWAP_PTR(snd->envelope); - if (!alreadySwapped((intptr_t)snd->envelope)) { - ALEnvelope *env = PD_PTR_BASE(snd->envelope, bankBase); - PD_SWAP_VAL(env->attackTime); - PD_SWAP_VAL(env->releaseTime); - PD_SWAP_VAL(env->decayTime); - } - } - - if (snd->keyMap) { - PD_SWAP_PTR(snd->keyMap); - } - - if (snd->wavetable) { - PD_SWAP_PTR(snd->wavetable); - preprocessALWaveTable(PD_PTR_BASE(snd->wavetable, bankBase), bankBase); - } -} - -static inline void preprocessALInstrument(ALInstrument *inst, u8 *bankBase) -{ - if (alreadySwapped((u8 *)inst - bankBase)) { - return; - } - - PD_SWAP_VAL(inst->bendRange); - PD_SWAP_VAL(inst->soundCount); - - for (s16 i = 0; i < inst->soundCount; ++i) { - PD_SWAP_PTR(inst->soundArray[i]); - preprocessALSound(PD_PTR_BASE(inst->soundArray[i], bankBase), bankBase); - } -} - -static inline void preprocessALBank(ALBank *bank, u8 *bankBase) -{ - if (alreadySwapped((u8 *)bank - bankBase)) { - return; - } - - PD_SWAP_VAL(bank->sampleRate); - PD_SWAP_VAL(bank->instCount); - - if (bank->percussion) { - PD_SWAP_PTR(bank->percussion); - preprocessALInstrument(PD_PTR_BASE(bank->percussion, bankBase), bankBase); - } - - for (s16 i = 0; i < bank->instCount; ++i) { - PD_SWAP_PTR(bank->instArray[i]); - preprocessALInstrument(PD_PTR_BASE(bank->instArray[i], bankBase), bankBase); - } -} - u8* preprocessAnimations(u8* data, u32 size, u32* outSize) { // set the anim table pointers as well @@ -198,22 +82,6 @@ u8* preprocessJpnFont(u8* data, u32 size, u32* outSize) return 0; } -// to be removed eventually #TODO -u8* preprocessALBankFile_x86(u8* data, u32 size, u32* outSize) -{ - memset(swapmap, 0, sizeof(swapmap)); - - ALBankFile *bankf = (ALBankFile *)data; - PD_SWAP_VAL(bankf->revision); - PD_SWAP_VAL(bankf->bankCount); - - for (s16 i = 0; i < bankf->bankCount; ++i) { - PD_SWAP_PTR(bankf->bankArray[i]); - preprocessALBank(PD_PTR_BASE(bankf->bankArray[i], data), data); - } - return 0; -} - void preprocessALCMidiHdr(u8 *data, u32 size) { ALCMidiHdr *hdr = (ALCMidiHdr *)data; From 23539a02a5e3c3dc9d12b7af4aff447947f9480d Mon Sep 17 00:00:00 2001 From: fgsfds Date: Sun, 10 Nov 2024 10:53:59 +0100 Subject: [PATCH 64/81] port: 64-bit cleanup: remove exit()/fprintf() --- port/src/preprocess/common.c | 3 +-- port/src/preprocess/common.h | 2 +- port/src/preprocess/filebg.c | 9 +++------ port/src/preprocess/filelang.c | 3 +-- port/src/preprocess/filemodel.c | 9 +++------ port/src/preprocess/filepads.c | 3 +-- port/src/preprocess/filesetup.c | 3 +-- port/src/preprocess/filetiles.c | 3 +-- port/src/preprocess/util_gbi.c | 3 +-- 9 files changed, 13 insertions(+), 25 deletions(-) diff --git a/port/src/preprocess/common.c b/port/src/preprocess/common.c index 774ff267d..4f3bde05c 100644 --- a/port/src/preprocess/common.c +++ b/port/src/preprocess/common.c @@ -7,8 +7,7 @@ static int m_NumPtrMarkers; void addMarker(u32 ptr_src, uintptr_t ptr_host) { if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { - sysLogPrintf(LOG_ERROR, "Marker limit exceeded"); - exit(EXIT_FAILURE); + sysFatalError("Marker limit exceeded"); } m_PtrMarkers[m_NumPtrMarkers].ptr_src = ptr_src; diff --git a/port/src/preprocess/common.h b/port/src/preprocess/common.h index 3d6aa1671..9b1cf7e39 100644 --- a/port/src/preprocess/common.h +++ b/port/src/preprocess/common.h @@ -26,7 +26,7 @@ #include "types.h" #include "constants.h" - +#include "system.h" #if __BIG_ENDIAN__ #define htonll(x) (x) diff --git a/port/src/preprocess/filebg.c b/port/src/preprocess/filebg.c index 95c909694..70b7f2e6a 100644 --- a/port/src/preprocess/filebg.c +++ b/port/src/preprocess/filebg.c @@ -306,8 +306,7 @@ void relinkPtr(uintptr_t* ptr) struct ptrmarker* marker = findPtrMarker(*ptr); if (!marker) { - fprintf(stderr, "[BG] WARNING: Unable to relink pointer: %p\n", ptr); - exit(EXIT_FAILURE); + sysFatalError("[BG] WARNING: Unable to relink pointer: %p\n", ptr); } *ptr = marker->ptr_host; @@ -554,8 +553,7 @@ void preprocessBgSection1(u8 *data, u32 size, u32 ofs) u32 newSize = convertSection1(dst, data, ofs); if (newSize > size) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); + sysFatalError("overflow when trying to preprocess a bg file, size %d newsize %d", size, newSize); } memcpy(data, dst, newSize); @@ -569,8 +567,7 @@ u32 preprocessBgRoom(u8 *data, u32 size, u32 room_ofs) u32 newSize = convertRoomGfxData(dst, data, size, room_ofs); if (newSize > size) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a bg room, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); + sysFatalError("overflow when trying to preprocess a bg room, size %d newsize %d", size, newSize); } memcpy(data, dst, newSize); diff --git a/port/src/preprocess/filelang.c b/port/src/preprocess/filelang.c index 46abe902c..408d9402b 100644 --- a/port/src/preprocess/filelang.c +++ b/port/src/preprocess/filelang.c @@ -82,8 +82,7 @@ u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize) { u32 newSize = convertLangFile(dst, data, size); if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a lang file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); + sysFatalError("overflow when trying to preprocess a lang file, size %d newsize %d", size, newSize); } memcpy(data, dst, newSize); diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index 9a0c6261f..ff006cd53 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -349,8 +349,7 @@ static void set_marker(u32 src_offset, enum contenttype type, u32 parent_src_off } if (m_NumMarkers >= ARRAYCOUNT(m_Markers)) { - fprintf(stderr, "Marker limit exceeded\n"); - exit(EXIT_FAILURE); + sysFatalError("Marker limit exceeded"); } m_Markers[m_NumMarkers].src_offset = src_offset; @@ -994,8 +993,7 @@ u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize) u32 newSize = convertModel(dst, data, size); if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); + sysFatalError("overflow when trying to preprocess model, size %d newsize %d", size, newSize); } memcpy(data, dst, newSize); @@ -1016,8 +1014,7 @@ u8 *preprocessGunFile(u8 *data, u32 size, u32 *outSize) u32 newSize = convertModel(dst, data, size); if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess model, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); + sysFatalError("overflow when trying to preprocess model, size %d newsize %d", size, newSize); } memcpy(data, dst, newSize); diff --git a/port/src/preprocess/filepads.c b/port/src/preprocess/filepads.c index 25e9ccf5e..3441740cb 100644 --- a/port/src/preprocess/filepads.c +++ b/port/src/preprocess/filepads.c @@ -316,8 +316,7 @@ u8* preprocessPadsFile(u8 *data, u32 size, u32 *outSize) { u32 newSize = convertPadsFile(dst, data); if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a pads file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); + sysFatalError("overflow when trying to preprocess a pads file, size %d newsize %d", size, newSize); } memcpy(data, dst, newSize); diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index 10ec0bfcf..d4d0727bc 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -1187,8 +1187,7 @@ u8 *preprocessSetupFile(u8 *data, u32 size, u32 *outSize) { u32 newSize = convertSetup(dst, data, size); if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a model file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); + sysFatalError("overflow when trying to preprocess a model file, size %d newsize %d", size, newSize); } memcpy(data, dst, newSize); diff --git a/port/src/preprocess/filetiles.c b/port/src/preprocess/filetiles.c index ed63c416a..df261536d 100644 --- a/port/src/preprocess/filetiles.c +++ b/port/src/preprocess/filetiles.c @@ -94,8 +94,7 @@ u8 *preprocessTilesFile(u8 *data, u32 size, u32 *outSize) u32 newSize = convertTiles(dst, data, size); if (newSize > newSizeEstimated) { - sysLogPrintf(LOG_ERROR, "overflow when trying to preprocess a tiles file, size %d newsize %d", size, newSize); - exit(EXIT_FAILURE); + sysFatalError("overflow when trying to preprocess a tiles file, size %d newsize %d", size, newSize); } memcpy(data, dst, newSize); diff --git a/port/src/preprocess/util_gbi.c b/port/src/preprocess/util_gbi.c index 680d22e75..c0b6dfd40 100644 --- a/port/src/preprocess/util_gbi.c +++ b/port/src/preprocess/util_gbi.c @@ -129,8 +129,7 @@ static u64 gbiRewriteAddr(u64 cmd, u8 opcode) } else { if (offset < m_SrcVtxOffset) { - printf("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, m_SrcVtxOffset); - exit(EXIT_FAILURE); + sysFatalError("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, m_SrcVtxOffset); } offset = offset - m_SrcVtxOffset + m_DstVtxOffset; From 5c2082f58e3cc3c7376a082d973e0b6c7c7ef1f3 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Sun, 10 Nov 2024 14:02:04 +0100 Subject: [PATCH 65/81] port: 64-bit cleanup: remove FileType, use LOADTYPE instead --- port/include/romdata.h | 11 +---------- port/src/preprocess/filelang.c | 2 +- port/src/preprocess/filemodel.c | 4 ++-- port/src/preprocess/filepads.c | 2 +- port/src/preprocess/filesetup.c | 2 +- port/src/preprocess/filetiles.c | 2 +- port/src/romdata.c | 20 ++++++++++---------- src/game/bg.c | 2 +- src/game/bondgun.c | 4 ++-- src/game/file.c | 8 ++++---- src/game/lang.c | 4 ++-- src/game/langreset.c | 14 +++++++------- src/game/menu.c | 6 +++--- src/game/modeldef.c | 2 +- src/game/player.c | 6 +++--- src/game/setup.c | 4 ++-- src/game/tilesreset.c | 2 +- src/include/game/file.h | 4 ++-- 18 files changed, 45 insertions(+), 54 deletions(-) diff --git a/port/include/romdata.h b/port/include/romdata.h index 545190eb8..6f64a602c 100644 --- a/port/include/romdata.h +++ b/port/include/romdata.h @@ -6,15 +6,6 @@ extern u8 *g_RomFile; extern u32 g_RomFileSize; -typedef enum { - FT_BG, - FT_TILES, - FT_LANG, - FT_SETUP, - FT_PADS, - FT_MODEL -} FileType; - s32 romdataInit(void); u8 *romdataFileLoad(s32 fileNum, u32 *outSize); @@ -30,7 +21,7 @@ s32 romdataFileGetNumForName(const char *name); u8 *romdataSegGetData(const char *segName); u8 *romdataSegGetDataEnd(const char *segName); u32 romdataSegGetSize(const char *segName); -u32 romdataFileGetEstimatedSize(u32 size, FileType filetype); +u32 romdataFileGetEstimatedSize(const u32 size, const u32 loadtype); s32 romdataCheckGbcRom(void); diff --git a/port/src/preprocess/filelang.c b/port/src/preprocess/filelang.c index 408d9402b..f9fd434ad 100644 --- a/port/src/preprocess/filelang.c +++ b/port/src/preprocess/filelang.c @@ -76,7 +76,7 @@ u32 convertLangFile(u8 *dst, u8 *src, size_t srclen) } u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_LANG); + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, LOADTYPE_LANG); u8 *dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convertLangFile(dst, data, size); diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index ff006cd53..ddab206da 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -987,7 +987,7 @@ u8 *preprocessModelFile(u8 *data, u32 size, u32 *outSize) { gbiReset(); - u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_MODEL); + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, LOADTYPE_MODEL); u8 *dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convertModel(dst, data, size); @@ -1008,7 +1008,7 @@ u8 *preprocessGunFile(u8 *data, u32 size, u32 *outSize) { gbiReset(); - u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_MODEL); + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, LOADTYPE_MODEL); u8 *dst = sysMemZeroAlloc(newSizeEstimated+128); u32 newSize = convertModel(dst, data, size); diff --git a/port/src/preprocess/filepads.c b/port/src/preprocess/filepads.c index 3441740cb..bcbbe1c69 100644 --- a/port/src/preprocess/filepads.c +++ b/port/src/preprocess/filepads.c @@ -310,7 +310,7 @@ static int convertPadsFile(u8 *dst, u8 *src) } u8* preprocessPadsFile(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_PADS); + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, LOADTYPE_PADS); u8* dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convertPadsFile(dst, data); diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index d4d0727bc..1ffd46d46 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -1181,7 +1181,7 @@ static int convertSetup(u8 *dst, u8 *src, u32 srclen) } u8 *preprocessSetupFile(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_SETUP); + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, LOADTYPE_SETUP); u8 *dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convertSetup(dst, data, size); diff --git a/port/src/preprocess/filetiles.c b/port/src/preprocess/filetiles.c index df261536d..db0e66f69 100644 --- a/port/src/preprocess/filetiles.c +++ b/port/src/preprocess/filetiles.c @@ -88,7 +88,7 @@ u32 convertTiles(u8 *dst, u8 *src, size_t srclen) u8 *preprocessTilesFile(u8 *data, u32 size, u32 *outSize) { - u32 newSizeEstimated = romdataFileGetEstimatedSize(size, FT_TILES); + u32 newSizeEstimated = romdataFileGetEstimatedSize(size, LOADTYPE_TILES); u8 *dst = sysMemZeroAlloc(newSizeEstimated); u32 newSize = convertTiles(dst, data, size); diff --git a/port/src/romdata.c b/port/src/romdata.c index e16315714..455659110 100644 --- a/port/src/romdata.c +++ b/port/src/romdata.c @@ -587,20 +587,20 @@ u32 romdataSegGetSize(const char *segName) return romdataGetSeg(segName)->size; } -u32 romdataFileGetEstimatedSize(u32 size, FileType filetype) +u32 romdataFileGetEstimatedSize(const u32 size, const u32 loadtype) { #ifdef PLATFORM_64BIT - switch (filetype) { - case FT_BG: return (u32)(size * 1.1); - case FT_TILES: return (u32)(size * 1.1); - case FT_LANG: return (u32)(size * 1.3); - case FT_SETUP: return (u32)(size * 1.5); - case FT_PADS: return (u32)(size * 1.7); - case FT_MODEL: return (u32)(size * 1.7); + switch (loadtype) { + case LOADTYPE_BG: return (u32)(size * 1.1f); + case LOADTYPE_TILES: return (u32)(size * 1.1f); + case LOADTYPE_LANG: return (u32)(size * 1.3f); + case LOADTYPE_SETUP: return (u32)(size * 1.5f); + case LOADTYPE_PADS: return (u32)(size * 1.7f); + case LOADTYPE_MODEL: return (u32)(size * 1.7f); + case LOADTYPE_GUN: return (u32)(size * 1.7f); default: - sysLogPrintf(LOG_WARNING, "wrong file type in romdataFileGetEstimatedSize: %d", filetype); + sysLogPrintf(LOG_WARNING, "romdataFileGetEstimatedSize: wrong loadtype %d", loadtype); } #endif return size; } - diff --git a/src/game/bg.c b/src/game/bg.c index 1ad070d12..0b71bbdf4 100644 --- a/src/game/bg.c +++ b/src/game/bg.c @@ -1512,7 +1512,7 @@ void bgReset(s32 stagenum) var8007fc54 -= 0xc; #ifdef PLATFORM_64BIT - inflatedsize = romdataFileGetEstimatedSize(inflatedsize, FT_BG); + inflatedsize = romdataFileGetEstimatedSize(inflatedsize, LOADTYPE_BG); #endif inflatedsize = ALIGN16(inflatedsize); diff --git a/src/game/bondgun.c b/src/game/bondgun.c index f82473f3a..857dc7a54 100644 --- a/src/game/bondgun.c +++ b/src/game/bondgun.c @@ -3832,7 +3832,7 @@ void bgunTickGunLoad(void) *player->gunctrl.loadmemptr = ptr; *player->gunctrl.loadmemremaining = remaining; - loadsize = ALIGN64(fileGetInflatedSize(player->gunctrl.loadfilenum, FT_MODEL)) + 0x8000; + loadsize = ALIGN64(fileGetInflatedSize(player->gunctrl.loadfilenum, LOADTYPE_MODEL)) + 0x8000; osSyncPrintf("BriGun: Loading - %s, pMem 0x%08x Size %d\n"); @@ -3934,7 +3934,7 @@ void bgunTickGunLoad(void) modeldef0f1a7560(modeldef, player->gunctrl.loadfilenum, 0x05000000, modeldef, &player->gunctrl.texpool, false); - fileGetInflatedSize(player->gunctrl.loadfilenum, FT_MODEL); + fileGetInflatedSize(player->gunctrl.loadfilenum, LOADTYPE_MODEL); fileGetLoadedSize(player->gunctrl.loadfilenum); fileGetLoadedSize(player->gunctrl.loadfilenum); fileGetLoadedSize(player->gunctrl.loadfilenum); diff --git a/src/game/file.c b/src/game/file.c index 825ebf7c1..95e486c25 100644 --- a/src/game/file.c +++ b/src/game/file.c @@ -4255,7 +4255,7 @@ void fileLoadPartToAddr(u16 filenum, void *memaddr, s32 offset, u32 len) } } -u32 fileGetInflatedSize(s32 filenum, FileType filetype) +u32 fileGetInflatedSize(s32 filenum, u32 loadtype) { u8 *ptr; u8 buffer[0x50]; @@ -4283,7 +4283,7 @@ u32 fileGetInflatedSize(s32 filenum, FileType filetype) } if (rzipIs1173(ptr)) { - return romdataFileGetEstimatedSize((ptr[2] << 16) | (ptr[3] << 8) | ptr[4], filetype); + return romdataFileGetEstimatedSize((ptr[2] << 16) | (ptr[3] << 8) | ptr[4], loadtype); } #if VERSION < VERSION_NTSC_1_0 @@ -4300,7 +4300,7 @@ u32 fileGetInflatedSize(s32 filenum, FileType filetype) return 0; } -void *fileLoadToNew(s32 filenum, u32 method, FileType filetype) +void *fileLoadToNew(s32 filenum, u32 method, u32 loadtype) { struct fileinfo *info = &g_FileInfo[filenum]; u32 stack; @@ -4308,7 +4308,7 @@ void *fileLoadToNew(s32 filenum, u32 method, FileType filetype) if (method == FILELOADMETHOD_EXTRAMEM || method == FILELOADMETHOD_DEFAULT) { if (info->loadedsize == 0) { - info->loadedsize = (fileGetInflatedSize(filenum, filetype) + 0x20) & 0xfffffff0; + info->loadedsize = (fileGetInflatedSize(filenum, loadtype) + 0x20) & 0xfffffff0; if (method == FILELOADMETHOD_EXTRAMEM) { info->loadedsize += 0x8000; diff --git a/src/game/lang.c b/src/game/lang.c index f7d61f336..b4c7bbd20 100644 --- a/src/game/lang.c +++ b/src/game/lang.c @@ -377,7 +377,7 @@ s32 langGetFileId(s32 bank) void langLoad(s32 bank) { #if VERSION >= VERSION_PAL_BETA - s32 len = fileGetInflatedSize(langGetFileId(bank), FT_LANG); + s32 len = fileGetInflatedSize(langGetFileId(bank), LOADTYPE_LANG); if ((uintptr_t)g_LangBuffer + len + g_LangBufferSize - (uintptr_t)g_LangBufferPos >= 0) { s32 len2 = (uintptr_t)g_LangBuffer + g_LangBufferSize - (uintptr_t)g_LangBufferPos; @@ -391,7 +391,7 @@ void langLoad(s32 bank) #else s32 file_id = langGetFileId(bank); g_LoadType = LOADTYPE_LANG; - g_LangBanks[bank] = fileLoadToNew(file_id, FILELOADMETHOD_DEFAULT, FT_LANG); + g_LangBanks[bank] = fileLoadToNew(file_id, FILELOADMETHOD_DEFAULT, LOADTYPE_LANG); #endif } diff --git a/src/game/langreset.c b/src/game/langreset.c index a85afd8dd..beabbde03 100644 --- a/src/game/langreset.c +++ b/src/game/langreset.c @@ -57,26 +57,26 @@ void langReset(s32 stagenum) #else // Versions prior to PAL load the language directly g_LoadType = LOADTYPE_LANG; // find be a better way to do this.. - g_LangBanks[LANGBANK_GUN] = fileLoadToNew(langGetFileId(LANGBANK_GUN), FILELOADMETHOD_DEFAULT, FT_LANG); + g_LangBanks[LANGBANK_GUN] = fileLoadToNew(langGetFileId(LANGBANK_GUN), FILELOADMETHOD_DEFAULT, LOADTYPE_LANG); g_LoadType = LOADTYPE_LANG; - g_LangBanks[LANGBANK_MPMENU] = fileLoadToNew(langGetFileId(LANGBANK_MPMENU), FILELOADMETHOD_DEFAULT, FT_LANG); + g_LangBanks[LANGBANK_MPMENU] = fileLoadToNew(langGetFileId(LANGBANK_MPMENU), FILELOADMETHOD_DEFAULT, LOADTYPE_LANG); g_LoadType = LOADTYPE_LANG; - g_LangBanks[LANGBANK_PROPOBJ] = fileLoadToNew(langGetFileId(LANGBANK_PROPOBJ), FILELOADMETHOD_DEFAULT, FT_LANG); + g_LangBanks[LANGBANK_PROPOBJ] = fileLoadToNew(langGetFileId(LANGBANK_PROPOBJ), FILELOADMETHOD_DEFAULT, LOADTYPE_LANG); g_LoadType = LOADTYPE_LANG; - g_LangBanks[LANGBANK_MPWEAPONS] = fileLoadToNew(langGetFileId(LANGBANK_MPWEAPONS), FILELOADMETHOD_DEFAULT, FT_LANG); + g_LangBanks[LANGBANK_MPWEAPONS] = fileLoadToNew(langGetFileId(LANGBANK_MPWEAPONS), FILELOADMETHOD_DEFAULT, LOADTYPE_LANG); g_LoadType = LOADTYPE_LANG; - g_LangBanks[LANGBANK_OPTIONS] = fileLoadToNew(langGetFileId(LANGBANK_OPTIONS), FILELOADMETHOD_DEFAULT, FT_LANG); + g_LangBanks[LANGBANK_OPTIONS] = fileLoadToNew(langGetFileId(LANGBANK_OPTIONS), FILELOADMETHOD_DEFAULT, LOADTYPE_LANG); g_LoadType = LOADTYPE_LANG; - g_LangBanks[LANGBANK_MISC] = fileLoadToNew(langGetFileId(LANGBANK_MISC), FILELOADMETHOD_DEFAULT, FT_LANG); + g_LangBanks[LANGBANK_MISC] = fileLoadToNew(langGetFileId(LANGBANK_MISC), FILELOADMETHOD_DEFAULT, LOADTYPE_LANG); if (stagenum == STAGE_CREDITS) { g_LoadType = LOADTYPE_LANG; - g_LangBanks[LANGBANK_TITLE] = fileLoadToNew(langGetFileId(LANGBANK_TITLE), FILELOADMETHOD_DEFAULT, FT_LANG); + g_LangBanks[LANGBANK_TITLE] = fileLoadToNew(langGetFileId(LANGBANK_TITLE), FILELOADMETHOD_DEFAULT, LOADTYPE_LANG); } #endif } diff --git a/src/game/menu.c b/src/game/menu.c index 8df5e4478..694b4fc63 100644 --- a/src/game/menu.c +++ b/src/game/menu.c @@ -1870,7 +1870,7 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) bodyfilenum = g_HeadsAndBodies[bodynum].filenum; - totalfilelen = fileGetInflatedSize(bodyfilenum, FT_MODEL); + totalfilelen = fileGetInflatedSize(bodyfilenum, LOADTYPE_MODEL); totalfilelen = ALIGN64(totalfilelen); if (g_HeadsAndBodies[bodynum].unk00_01) { @@ -1878,7 +1878,7 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) headfilenum = 0xffff; } else { headfilenum = g_HeadsAndBodies[headnum].filenum; - totalfilelen += ALIGN64(fileGetInflatedSize(headfilenum, FT_MODEL)); + totalfilelen += ALIGN64(fileGetInflatedSize(headfilenum, LOADTYPE_MODEL)); } #ifdef PLATFORM_64BIT @@ -1916,7 +1916,7 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype) body0f02ce8c(bodynum, headnum, menumodel->bodymodeldef, menumodel->headmodeldef, totalfilelen * 0, &menumodel->bodymodel, false, 1); } else { - totalfilelen = ALIGN64(fileGetInflatedSize(menumodel->newparams, FT_MODEL)) + 0x4000; + totalfilelen = ALIGN64(fileGetInflatedSize(menumodel->newparams, LOADTYPE_MODEL)) + 0x4000; if (1); texInitPool(&texpool, &menumodel->allocstart[(u32)totalfilelen], menumodel->alloclen - totalfilelen); diff --git a/src/game/modeldef.c b/src/game/modeldef.c index ef2d13023..b3c3307a6 100644 --- a/src/game/modeldef.c +++ b/src/game/modeldef.c @@ -190,7 +190,7 @@ struct modeldef *modeldefLoad(u16 fileid, u8 *dst, s32 size, struct texpool *arg if (dst) { modeldef = fileLoadToAddr(fileid, FILELOADMETHOD_EXTRAMEM, dst, size); } else { - modeldef = fileLoadToNew(fileid, FILELOADMETHOD_EXTRAMEM, FT_MODEL); + modeldef = fileLoadToNew(fileid, FILELOADMETHOD_EXTRAMEM, LOADTYPE_MODEL); } modelPromoteTypeToPointer(modeldef); diff --git a/src/game/player.c b/src/game/player.c index 4d2eb6389..b2fdf891b 100644 --- a/src/game/player.c +++ b/src/game/player.c @@ -1434,14 +1434,14 @@ void playerTickChrBody(void) offset1 += sizeof(struct weaponobj); offset1 = ALIGN64(offset1); - offset2 = offset1 + ALIGN64(fileGetInflatedSize(g_HeadsAndBodies[bodynum].filenum, FT_MODEL)); + offset2 = offset1 + ALIGN64(fileGetInflatedSize(g_HeadsAndBodies[bodynum].filenum, LOADTYPE_MODEL)); if (headnum >= 0) { - offset2 += ALIGN64(fileGetInflatedSize(g_HeadsAndBodies[headnum].filenum, FT_MODEL)); + offset2 += ALIGN64(fileGetInflatedSize(g_HeadsAndBodies[headnum].filenum, LOADTYPE_MODEL)); } if (weaponmodelnum >= 0) { - offset2 += ALIGN64(fileGetInflatedSize(g_ModelStates[weaponmodelnum].fileid, FT_MODEL)); + offset2 += ALIGN64(fileGetInflatedSize(g_ModelStates[weaponmodelnum].fileid, LOADTYPE_MODEL)); } offset2 += 0x4000; diff --git a/src/game/setup.c b/src/game/setup.c index 491ca501f..ddf49953b 100644 --- a/src/game/setup.c +++ b/src/game/setup.c @@ -1319,7 +1319,7 @@ void setupLoadFiles(s32 stagenum) g_LoadType = LOADTYPE_SETUP; - g_GeCreditsData = (u8 *)fileLoadToNew(filenum, FILELOADMETHOD_DEFAULT, FT_SETUP); + g_GeCreditsData = (u8 *)fileLoadToNew(filenum, FILELOADMETHOD_DEFAULT, LOADTYPE_SETUP); setup = (struct stagesetup *)g_GeCreditsData; langLoad(langGetLangBankIndexFromStagenum(stagenum)); @@ -1330,7 +1330,7 @@ void setupLoadFiles(s32 stagenum) g_LoadType = LOADTYPE_PADS; - g_StageSetup.padfiledata = fileLoadToNew(g_Stages[g_StageIndex].padsfileid, FILELOADMETHOD_DEFAULT, FT_PADS); + g_StageSetup.padfiledata = fileLoadToNew(g_Stages[g_StageIndex].padsfileid, FILELOADMETHOD_DEFAULT, LOADTYPE_PADS); g_StageSetup.waypoints = NULL; g_StageSetup.waygroups = NULL; diff --git a/src/game/tilesreset.c b/src/game/tilesreset.c index c87400ed0..f88795a12 100644 --- a/src/game/tilesreset.c +++ b/src/game/tilesreset.c @@ -18,7 +18,7 @@ void tilesReset(void) } g_LoadType = LOADTYPE_TILES; - g_TileFileData.u8 = fileLoadToNew(g_Stages[index].tilefileid, FILELOADMETHOD_DEFAULT, FT_TILES); + g_TileFileData.u8 = fileLoadToNew(g_Stages[index].tilefileid, FILELOADMETHOD_DEFAULT, LOADTYPE_TILES); g_TileNumRooms = *g_TileFileData.u32; g_TileRooms = g_TileFileData.u32 + 1; diff --git a/src/include/game/file.h b/src/include/game/file.h index 22908feb9..24fee6c0a 100644 --- a/src/include/game/file.h +++ b/src/include/game/file.h @@ -12,8 +12,8 @@ romptr_t fileGetRomAddress(s32 filenum); s32 fileGetRomSize(s32 filenum); void filesInit(void); void fileLoadPartToAddr(u16 filenum, void *memaddr, s32 offset, u32 len); -u32 fileGetInflatedSize(s32 filenum, FileType filetype); -void *fileLoadToNew(s32 filenum, u32 method, FileType filetype); +u32 fileGetInflatedSize(s32 filenum, u32 loadtype); +void *fileLoadToNew(s32 filenum, u32 method, u32 loadtype); void *fileLoadToAddr(s32 filenum, s32 method, u8 *ptr, u32 size); u32 fileGetLoadedSize(s32 filenum); u32 fileGetAllocationSize(s32 filenum); From 25cdfc991b4d3fb2b3cedb618e422e47f96f3eb0 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Sun, 10 Nov 2024 15:24:26 +0100 Subject: [PATCH 66/81] port: 64-bit cleanup: don't use int128 to copy Gfx around --- include/PR/gbi.h | 2 +- src/game/tex.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/PR/gbi.h b/include/PR/gbi.h index 84bbad552..d26d787f0 100644 --- a/include/PR/gbi.h +++ b/include/PR/gbi.h @@ -1645,7 +1645,7 @@ typedef union { #endif GunkC0 unkc0; #ifdef PLATFORM_64BIT - __int128 force_structure_alignment; + long long int force_structure_alignment[2]; #else long long int force_structure_alignment; #endif diff --git a/src/game/tex.c b/src/game/tex.c index f7d226b15..b46b9e8b0 100644 --- a/src/game/tex.c +++ b/src/game/tex.c @@ -1172,7 +1172,7 @@ void texCopyGdls(Gfx *src, Gfx *dst, s32 count) dst = dst + (count - 1); while (count--) { - dst->force_structure_alignment = src->force_structure_alignment; + *dst = *src; dst--; src--; } From 16f025cbbe6ed2d04e4472bce2c6eaa851ecd2b2 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Sun, 10 Nov 2024 15:25:47 +0100 Subject: [PATCH 67/81] port: 64-bit: fix pointer length in mp3.c --- src/lib/mp3.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/mp3.c b/src/lib/mp3.c index 1d20d9151..37e3de385 100644 --- a/src/lib/mp3.c +++ b/src/lib/mp3.c @@ -417,7 +417,7 @@ s32 func00038ba8(s32 arg0, u8 *arg1, s32 arg2, s32 arg3) void mp3Dma(void) { - u32 state; + uintptr_t state; ALDMAproc proc; proc = n_syn->dma(&state); From 19ef4738b76722bd1692b2829c446dabb85b3795 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Mon, 11 Nov 2024 20:44:09 +0100 Subject: [PATCH 68/81] port: 64-bit: fix matrices on x86_64-linux --- include/PR/gbi.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/PR/gbi.h b/include/PR/gbi.h index d26d787f0..7663d3033 100644 --- a/include/PR/gbi.h +++ b/include/PR/gbi.h @@ -1059,7 +1059,7 @@ typedef struct { // 4x4 float matrix typedef float Mtx_t[4][4]; #else -typedef long Mtx_t[4][4]; +typedef int32_t Mtx_t[4][4]; #endif typedef union { From 68e3a79e47edfc1bed4a5552309c77b384cdb2a9 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 10:11:23 +0100 Subject: [PATCH 69/81] port: 64-bit: replace another long --- include/PR/gu.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/PR/gu.h b/include/PR/gu.h index 7744bdf92..3b5518c7b 100644 --- a/include/PR/gu.h +++ b/include/PR/gu.h @@ -35,7 +35,7 @@ #define OS_M_PI 3.14159265358979323846 #define M_DTOR (3.14159265358979323846/180.0) -#define FTOFIX32(x) (long)((x) * (float)0x00010000) +#define FTOFIX32(x) (int)((x) * (float)0x00010000) #define FIX32TOF(x) ((float)(x) * (1.0f / (float)0x00010000)) #define FTOFRAC8(x) ((int) MIN(((x) * (128.0f)), 127.0f) & 0xff) From 1448cd597a432fd747916e2535c8d4053ccbf7d8 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 10:34:10 +0100 Subject: [PATCH 70/81] port: 64-bit: more cleanup replace the byte swapping macros with the ones from platform.h rename and move things to match the rest of the code --- port/include/preprocess/common.h | 57 ++++ port/include/preprocess/gbi.h | 15 + .../preprocess/setup.h} | 5 +- port/src/preprocess/common.c | 31 +- port/src/preprocess/common.h | 129 -------- port/src/preprocess/filebg.c | 131 ++++---- port/src/preprocess/filelang.c | 12 +- port/src/preprocess/filemodel.c | 293 +++++++++--------- port/src/preprocess/filepads.c | 117 ++++--- port/src/preprocess/filesetup.c | 52 ++-- port/src/preprocess/filetiles.c | 29 +- port/src/preprocess/{util_gbi.c => gbi.c} | 26 +- port/src/preprocess/{preprocess.c => misc.c} | 8 +- port/src/preprocess/segaudio.c | 81 +++-- port/src/preprocess/segfonts.c | 20 +- 15 files changed, 458 insertions(+), 548 deletions(-) create mode 100644 port/include/preprocess/common.h create mode 100644 port/include/preprocess/gbi.h rename port/{src/preprocess/setups_decl.h => include/preprocess/setup.h} (99%) delete mode 100644 port/src/preprocess/common.h rename port/src/preprocess/{util_gbi.c => gbi.c} (91%) rename port/src/preprocess/{preprocess.c => misc.c} (97%) diff --git a/port/include/preprocess/common.h b/port/include/preprocess/common.h new file mode 100644 index 000000000..7ad5c0c09 --- /dev/null +++ b/port/include/preprocess/common.h @@ -0,0 +1,57 @@ +#ifndef _IN_PREPROCESS_COMMON_H +#define _IN_PREPROCESS_COMMON_H + +#include +#include +#include +#include + +#include +#include "types.h" +#include "constants.h" + +#include "platform.h" +#include "system.h" +#include "romdata.h" +#include "preprocess.h" + +#define MAX_PTR_MARKERS (1024 * 8) + +#define PD_ALIGN(val, size) (((val) + ((size) - 1)) & ~((size) - 1)) + +#define PD_PTR_BASE(x, b) (void *)((u8 *)b + (uintptr_t)x) +#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (uintptr_t)x) + +static inline f32 swapF32(f32 x) { *(u32*)&x = PD_BE32(*(u32*)&x); return x; } +static inline u32 swapU32(u32 x) { return PD_BE32(x); } +static inline s32 swapS32(s32 x) { return PD_BE32(x); } +static inline u16 swapU16(u16 x) { return PD_BE16(x); } +static inline s16 swapS16(s16 x) { return PD_BE16(x); } +static inline void* swapPtr(void** x) { return (void*)PD_BEPTR((uintptr_t)x); } +static inline struct coord swapCrd(struct coord crd) { crd.x = swapF32(crd.x); crd.y = swapF32(crd.y); crd.z = swapF32(crd.z); return crd; } +static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } + +#define PD_SWAP_VAL(x) x = _Generic((x), \ + f32: swapF32, \ + u32: swapU32, \ + s32: swapS32, \ + u16: swapU16, \ + s16: swapS16, \ + struct coord: swapCrd, \ + default: swapUnk \ +)(x) + +#define PD_SWAP_PTR(x) x = swapPtr((void *)(x)) + +// ptr marker functions + +struct ptrmarker { + u32 ptr_src; + uintptr_t ptr_host; +}; + +void ptrAdd(u32 ptr_src, uintptr_t ptr_host); +struct ptrmarker* ptrFind(uintptr_t ptr_src); +void ptrReset(void); + +#endif diff --git a/port/include/preprocess/gbi.h b/port/include/preprocess/gbi.h new file mode 100644 index 000000000..3752ceebe --- /dev/null +++ b/port/include/preprocess/gbi.h @@ -0,0 +1,15 @@ +#ifndef _IN_PREPROCESS_GBI_H +#define _IN_PREPROCESS_GBI_H + +#include "preprocess/common.h" + +// gbi related functions +void gbiReset(void); +void gbiSetSegment(int segment, u32 offset); +void gbiSetVtx(u32 src_offset, u32 dst_offset); +u32 gbiConvertGdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds); +void gbiConvertVtx(u8* dst, u32 dstpos, int count); +void gbiGdlRewriteAddrs(u8* dst, u32 offset); +void gbiAddTexAddr(u32 src_offset, u32 dst_offset); + +#endif diff --git a/port/src/preprocess/setups_decl.h b/port/include/preprocess/setup.h similarity index 99% rename from port/src/preprocess/setups_decl.h rename to port/include/preprocess/setup.h index e78afd62b..f8bcff391 100644 --- a/port/src/preprocess/setups_decl.h +++ b/port/include/preprocess/setup.h @@ -1,8 +1,7 @@ #ifndef _IN_SETUP_DECL #define _IN_SETUP_DECL -#include "common.h" - +#include "preprocess/common.h" struct n64_stagesetup { u32 ptr_waypoints; @@ -639,4 +638,4 @@ struct n64_path { u16 len; }; -#endif \ No newline at end of file +#endif diff --git a/port/src/preprocess/common.c b/port/src/preprocess/common.c index 4f3bde05c..31b45a79a 100644 --- a/port/src/preprocess/common.c +++ b/port/src/preprocess/common.c @@ -1,32 +1,31 @@ -#include "common.h" -#include "system.h" +#include "preprocess/common.h" -static struct ptrmarker m_PtrMarkers[1024*8]; -static int m_NumPtrMarkers; +static struct ptrmarker ptrMarkers[MAX_PTR_MARKERS]; +static int numPtrMarkers; -void addMarker(u32 ptr_src, uintptr_t ptr_host) +void ptrAdd(u32 ptr_src, uintptr_t ptr_host) { - if (m_NumPtrMarkers >= ARRAYCOUNT(m_PtrMarkers)) { - sysFatalError("Marker limit exceeded"); + if (numPtrMarkers >= ARRAYCOUNT(ptrMarkers)) { + sysFatalError("ptrAdd(%p, %p): ptrmarker limit exceeded", (void *)(uintptr_t)ptr_src, (void *)ptr_host); } - m_PtrMarkers[m_NumPtrMarkers].ptr_src = ptr_src; - m_PtrMarkers[m_NumPtrMarkers].ptr_host = ptr_host; - m_NumPtrMarkers++; + ptrMarkers[numPtrMarkers].ptr_src = ptr_src; + ptrMarkers[numPtrMarkers].ptr_host = ptr_host; + numPtrMarkers++; } -struct ptrmarker* findPtrMarker(uintptr_t ptr_src) +struct ptrmarker *ptrFind(uintptr_t ptr_src) { - for (int i = 0; i < m_NumPtrMarkers; i++) { - if (m_PtrMarkers[i].ptr_src == ptr_src) { - return &m_PtrMarkers[i]; + for (int i = 0; i < numPtrMarkers; i++) { + if (ptrMarkers[i].ptr_src == ptr_src) { + return &ptrMarkers[i]; } } return NULL; } -void resetMarkers() +void ptrReset(void) { - m_NumPtrMarkers = 0; + numPtrMarkers = 0; } diff --git a/port/src/preprocess/common.h b/port/src/preprocess/common.h deleted file mode 100644 index 9b1cf7e39..000000000 --- a/port/src/preprocess/common.h +++ /dev/null @@ -1,129 +0,0 @@ -#ifndef _PDE_COMMON_H -#define _PDE_COMMON_H - -#include -#include -#include -#include -#include "platform.h" - -#ifdef PLATFORM_WIN32 - -#include -// this BS comes from windows.h -#undef near -#undef far - -#else - -#include - -#endif - -#include - -#include - -#include "types.h" -#include "constants.h" -#include "system.h" - -#if __BIG_ENDIAN__ - #define htonll(x) (x) - #define ntohll(x) (x) -#else - #define htonll(x) ((((uint64_t)htonl(x&0xFFFFFFFF)) << 32) + htonl(x >> 32)) - #define ntohll(x) ((((uint64_t)ntohl(x&0xFFFFFFFF)) << 32) + ntohl(x >> 32)) -#endif - -#define htobe16(x) htons(x) -#define htole16(x) (x) -#define be16toh(x) ntohs(x) -#define le16toh(x) (x) - -#define htobe32(x) htonl(x) -#define htole32(x) (x) -#define be32toh(x) ntohl(x) -#define le32toh(x) (x) - -#define htobe64(x) htonll(x) -#define htole64(x) (x) -#define be64toh(x) ntohll(x) -#define le64toh(x) (x) - - -#define srctoh16(value) ntohs(value) -#define srctoh32(value) ntohl(value) -#define srctoh64(value) ntohll(value) - -#ifdef FORCE_BE32 -#define htodst16(value) htons(value) -#define htodst32(value) htonl(value) -#define htodst64(value) htonll(value) -#define dsttoh16(value) ntohs(value) -#define dsttoh32(value) ntohl(value) -#define dsttoh64(value) ntohll(value) -#else -#define htodst16(value) (value) -#define htodst32(value) (value) -#define htodst64(value) (value) -#define dsttoh16(value) (value) -#define dsttoh32(value) (value) -#define dsttoh64(value) (value) -#endif - -#define srctodst16(value) htodst16(srctoh16(value)) -#define srctodst32(value) htodst32(srctoh32(value)) -#define srctodst64(value) htodst64(srctoh64(value)) - -#ifdef FORCE_BE32 -#define uintptr_t u32 -#endif - -#define ALIGN(val, size) ((val + (size - 1)) & ~(size - 1)) - -#define PD_PTR_BASE(x, b) (void *)((u8 *)b + (uintptr_t)x) -#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (uintptr_t)x) - - -static inline f32 swapF32(f32 x) { *(u32*)&x = PD_BE32(*(u32*)&x); return x; } -static inline u32 swapU32(u32 x) { return PD_BE32(x); } -static inline s32 swapS32(s32 x) { return PD_BE32(x); } -static inline u16 swapU16(u16 x) { return PD_BE16(x); } -static inline s16 swapS16(s16 x) { return PD_BE16(x); } -static inline void* swapPtr(void** x) { return (void*)PD_BEPTR((uintptr_t)x); } -static inline struct coord swapCrd(struct coord crd) { crd.x = swapF32(crd.x); crd.y = swapF32(crd.y); crd.z = swapF32(crd.z); return crd; } -static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } - -#define PD_SWAP_VAL(x) x = _Generic((x), \ - f32: swapF32, \ - u32: swapU32, \ - s32: swapS32, \ - u16: swapU16, \ - s16: swapS16, \ - struct coord: swapCrd, \ - default: swapUnk \ -)(x) - -#define PD_SWAP_PTR(x) x = swapPtr((void *)(x)) - -// gbi related functions -void gbiReset(void); -void gbiSetSegment(int segment, u32 offset); -void gbiSetVtx(u32 src_offset, u32 dst_offset); -u32 gbiConvertGdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds); -void gbiConvertVtx(u8* dst, u32 dstpos, int count); -void gbiGdlRewriteAddrs(u8* dst, u32 offset); -void gbiAddTexAddr(u32 src_offset, u32 dst_offset); - -// ptr marker functions -struct ptrmarker { - u32 ptr_src; - uintptr_t ptr_host; -}; - -void addMarker(u32 ptr_src, uintptr_t ptr_host); -struct ptrmarker* findPtrMarker(uintptr_t ptr_src); -void resetMarkers(); - -#endif diff --git a/port/src/preprocess/filebg.c b/port/src/preprocess/filebg.c index 70b7f2e6a..3fe50fe9c 100644 --- a/port/src/preprocess/filebg.c +++ b/port/src/preprocess/filebg.c @@ -5,12 +5,9 @@ #include "data.h" #include "bss.h" -#include "platform.h" -#include "common.h" -#include "system.h" - -int m_SizeGDLs; +#include "preprocess/common.h" +#include "preprocess/gbi.h" /** * 4 bytes decompressed size of primary data @@ -180,10 +177,10 @@ static void convertPrimaryRooms(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) } for (int i = 0; i < m_NumRooms + 1; i++) { - host_rooms[i].ptr_gfxdata = srctodst32(n64_rooms[i].ptr_gfxdata); - host_rooms[i].pos[0] = srctodst32(n64_rooms[i].pos[0]); - host_rooms[i].pos[1] = srctodst32(n64_rooms[i].pos[1]); - host_rooms[i].pos[2] = srctodst32(n64_rooms[i].pos[2]); + host_rooms[i].ptr_gfxdata = PD_BE32(n64_rooms[i].ptr_gfxdata); + host_rooms[i].pos[0] = PD_BE32(n64_rooms[i].pos[0]); + host_rooms[i].pos[1] = PD_BE32(n64_rooms[i].pos[1]); + host_rooms[i].pos[2] = PD_BE32(n64_rooms[i].pos[2]); host_rooms[i].br_light_min = n64_rooms[i].br_light_min; host_rooms[i].br_light_max = n64_rooms[i].br_light_max; } @@ -206,9 +203,9 @@ static void convertPrimaryPortals(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u3 // Convert portals for (int i = 0; i < numportals; i++) { - host_portals[i].verticesoffset = srctodst16(n64_portals[i].verticesoffset); - host_portals[i].roomnum1 = srctodst16(n64_portals[i].roomnum1); - host_portals[i].roomnum2 = srctodst16(n64_portals[i].roomnum2); + host_portals[i].verticesoffset = PD_BE16(n64_portals[i].verticesoffset); + host_portals[i].roomnum1 = PD_BE16(n64_portals[i].roomnum1); + host_portals[i].roomnum2 = PD_BE16(n64_portals[i].roomnum2); host_portals[i].flags = n64_portals[i].flags; } @@ -225,12 +222,12 @@ static void convertPrimaryPortals(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u3 host_pvertices->count = n64_pvertices->count; for (int j = 0; j < host_pvertices->count; j++) { - //host_pvertices->vertices[j].x = srctodst32(n64_pvertices->vertices[j].x); - //host_pvertices->vertices[j].y = srctodst32(n64_pvertices->vertices[j].y); - //host_pvertices->vertices[j].z = srctodst32(n64_pvertices->vertices[j].z); - host_pvertices->vertices[j][0] = srctodst32(n64_pvertices->vertices[j][0]); - host_pvertices->vertices[j][1] = srctodst32(n64_pvertices->vertices[j][1]); - host_pvertices->vertices[j][2] = srctodst32(n64_pvertices->vertices[j][2]); + //host_pvertices->vertices[j].x = PD_BE32(n64_pvertices->vertices[j].x); + //host_pvertices->vertices[j].y = PD_BE32(n64_pvertices->vertices[j].y); + //host_pvertices->vertices[j].z = PD_BE32(n64_pvertices->vertices[j].z); + host_pvertices->vertices[j][0] = PD_BE32(n64_pvertices->vertices[j][0]); + host_pvertices->vertices[j][1] = PD_BE32(n64_pvertices->vertices[j][1]); + host_pvertices->vertices[j][2] = PD_BE32(n64_pvertices->vertices[j][2]); } *srcpos += 4 + host_pvertices->count * 12; @@ -255,7 +252,7 @@ static void convertPrimaryBgCmds(u8 *dst, u32 *dstpos, u8 *src, u32 dst_portalvt for (int i = 0; i < num_cmds; i++) { host_cmds[i].type = n64_cmds[i].type; host_cmds[i].len = n64_cmds[i].len; - host_cmds[i].param = srctodst32(n64_cmds[i].param); + host_cmds[i].param = PD_BE32(n64_cmds[i].param); if (host_cmds[i].type == 0x64) { u32 offset = host_cmds[i].param - src_portalvtxs; @@ -273,8 +270,8 @@ static void convertPrimaryLights(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 int num_lights = (end - *srcpos) / sizeof(struct light); for (int i = 0; i < num_lights; i++) { - host_lights[i].roomnum = srctodst16(n64_lights[i].roomnum); - host_lights[i].colour = srctodst16(n64_lights[i].colour); + host_lights[i].roomnum = PD_BE16(n64_lights[i].roomnum); + host_lights[i].colour = PD_BE16(n64_lights[i].colour); host_lights[i].brightness = n64_lights[i].brightness; host_lights[i].sparkable = n64_lights[i].sparkable; host_lights[i].healthy = n64_lights[i].healthy; @@ -287,9 +284,9 @@ static void convertPrimaryLights(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 host_lights[i].dirz = n64_lights[i].dirz; for (int j = 0; j < 4; j++) { - host_lights[i].bbox[j].x = srctodst16(n64_lights[i].bbox[j].x); - host_lights[i].bbox[j].y = srctodst16(n64_lights[i].bbox[j].y); - host_lights[i].bbox[j].z = srctodst16(n64_lights[i].bbox[j].z); + host_lights[i].bbox[j].x = PD_BE16(n64_lights[i].bbox[j].x); + host_lights[i].bbox[j].y = PD_BE16(n64_lights[i].bbox[j].y); + host_lights[i].bbox[j].z = PD_BE16(n64_lights[i].bbox[j].z); } } @@ -304,7 +301,7 @@ void relinkPtr(uintptr_t* ptr) { if (!*ptr) return; - struct ptrmarker* marker = findPtrMarker(*ptr); + struct ptrmarker* marker = ptrFind(*ptr); if (!marker) { sysFatalError("[BG] WARNING: Unable to relink pointer: %p\n", ptr); } @@ -314,7 +311,7 @@ void relinkPtr(uintptr_t* ptr) static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) { - resetMarkers(); + ptrReset(); gbiReset(); u32 dst_roomoffset = src_ofs; @@ -325,14 +322,14 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) struct n64_roomgfxdata *src_header = (struct n64_roomgfxdata*)src; struct host_roomgfxdata *dst_header = (struct host_roomgfxdata*)dst; - dst_header->ptr_vertices = srctoh32(src_header->ptr_vertices); - dst_header->ptr_colours = srctoh32(src_header->ptr_colours); - dst_header->ptr_opablocks = srctoh32(src_header->ptr_opablocks); - dst_header->ptr_xlublocks = srctoh32(src_header->ptr_xlublocks); - dst_header->lightsindex = srctoh16(src_header->lightsindex); - dst_header->numlights = srctoh16(src_header->numlights); - dst_header->numvertices = srctoh16(src_header->numvertices); - dst_header->numcolours = srctoh16(src_header->numcolours); + dst_header->ptr_vertices = PD_BE32(src_header->ptr_vertices); + dst_header->ptr_colours = PD_BE32(src_header->ptr_colours); + dst_header->ptr_opablocks = PD_BE32(src_header->ptr_opablocks); + dst_header->ptr_xlublocks = PD_BE32(src_header->ptr_xlublocks); + dst_header->lightsindex = PD_BE16(src_header->lightsindex); + dst_header->numlights = PD_BE16(src_header->numlights); + dst_header->numvertices = PD_BE16(src_header->numvertices); + dst_header->numcolours = PD_BE16(src_header->numcolours); intptr_t endpos = dst_header->ptr_vertices - src_ofs; uintptr_t curpos_src = sizeof(struct n64_roomgfxdata); @@ -350,12 +347,12 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) struct host_roomblock *dest_roomblock = (struct host_roomblock*)&dst[curpos_dst]; dest_roomblock->type = src_roomblock->type; - dest_roomblock->ptr_next = srctoh32(src_roomblock->ptr_next); - dest_roomblock->ptr_gdl = srctoh32(src_roomblock->ptr_gdl); - dest_roomblock->ptr_vertices = srctoh32(src_roomblock->ptr_vertices); - dest_roomblock->ptr_colours = srctoh32(src_roomblock->ptr_colours); + dest_roomblock->ptr_next = PD_BE32(src_roomblock->ptr_next); + dest_roomblock->ptr_gdl = PD_BE32(src_roomblock->ptr_gdl); + dest_roomblock->ptr_vertices = PD_BE32(src_roomblock->ptr_vertices); + dest_roomblock->ptr_colours = PD_BE32(src_roomblock->ptr_colours); - addMarker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + ptrAdd(curpos_src + src_ofs, curpos_dst + dst_roomoffset); if (src_roomblock->type == BLOCK_PARENT) { ncoords++; @@ -363,7 +360,7 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) if (vtx_ptr < endpos) endpos = vtx_ptr; } else if (src_roomblock->ptr_gdl) { - gdls_addr[numgdls++] = srctoh32(src_roomblock->ptr_gdl) - src_ofs; + gdls_addr[numgdls++] = PD_BE32(src_roomblock->ptr_gdl) - src_ofs; } curpos_src += sizeof(struct n64_roomblock); @@ -376,15 +373,15 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) u32 *src_coord = (u32*)(src + curpos_src); u32 *dst_coord = (u32*)(dst + curpos_dst); - dst_coord[0] = srctoh32(src_coord[0]); - dst_coord[1] = srctoh32(src_coord[1]); - dst_coord[2] = srctoh32(src_coord[2]); + dst_coord[0] = PD_BE32(src_coord[0]); + dst_coord[1] = PD_BE32(src_coord[1]); + dst_coord[2] = PD_BE32(src_coord[2]); - dst_coord[3] = srctoh32(src_coord[3]); - dst_coord[4] = srctoh32(src_coord[4]); - dst_coord[5] = srctoh32(src_coord[5]); + dst_coord[3] = PD_BE32(src_coord[3]); + dst_coord[4] = PD_BE32(src_coord[4]); + dst_coord[5] = PD_BE32(src_coord[5]); - addMarker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + ptrAdd(curpos_src + src_ofs, curpos_dst + dst_roomoffset); curpos_src += 6 * sizeof(u32); curpos_dst += 6 * sizeof(u32); @@ -396,7 +393,7 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) uintptr_t ptr_src_vertices = curpos_src = ALIGN8(dst_header->ptr_vertices - src_ofs); uintptr_t ptr_dst_vertices = curpos_dst + dst_roomoffset; - addMarker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + ptrAdd(curpos_src + src_ofs, curpos_dst + dst_roomoffset); uintptr_t vtx_end = dst_header->ptr_colours - src_ofs; @@ -404,15 +401,15 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) struct vtx *src_vtx = (struct vtx*)(src + curpos_src); struct vtx *dst_vtx = (struct vtx*)(dst + curpos_dst); - dst_vtx->coord[0] = srctoh16(src_vtx->coord[0]); - dst_vtx->coord[1] = srctoh16(src_vtx->coord[1]); - dst_vtx->coord[2] = srctoh16(src_vtx->coord[2]); + dst_vtx->coord[0] = PD_BE16(src_vtx->coord[0]); + dst_vtx->coord[1] = PD_BE16(src_vtx->coord[1]); + dst_vtx->coord[2] = PD_BE16(src_vtx->coord[2]); dst_vtx->flag = src_vtx->flag; dst_vtx->color = src_vtx->color; - dst_vtx->s = srctoh16(src_vtx->s); - dst_vtx->t = srctoh16(src_vtx->t); + dst_vtx->s = PD_BE16(src_vtx->s); + dst_vtx->t = PD_BE16(src_vtx->t); curpos_src += sizeof(struct vtx); curpos_dst += sizeof(struct vtx); @@ -428,7 +425,7 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) ptr_src_colors = curpos_src = ALIGN8(dst_header->ptr_colours - src_ofs); ptr_dst_colors = curpos_dst + dst_roomoffset; - addMarker(curpos_src + src_ofs, curpos_dst + dst_roomoffset); + ptrAdd(curpos_src + src_ofs, curpos_dst + dst_roomoffset); uintptr_t col_end = numgdls > 0 != 0 ? gdls_addr[0] : infsize; size_t col_len = col_end - curpos_src; @@ -441,14 +438,12 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) // gdls gbiSetVtx(src_header->ptr_vertices, ptr_src_vertices); gbiSetSegment(0x0e, dst_header->ptr_vertices); - - m_SizeGDLs = 0; + uintptr_t gdlstart = curpos_dst; for (size_t i = 0; i < numgdls; i++) { - addMarker(gdls_addr[i] + src_ofs, curpos_dst + dst_roomoffset); + ptrAdd(gdls_addr[i] + src_ofs, curpos_dst + dst_roomoffset); curpos_dst = gbiConvertGdl(dst, curpos_dst, src, gdls_addr[i], 1); } - m_SizeGDLs = curpos_dst - gdlstart; // relink ptrs: roomblocks for (size_t i = 0; i < numblocks; i++) { @@ -489,7 +484,7 @@ static u32 convertSection1(u8 *dst, u8 *src, u32 ofs) srcpos += sizeof(struct n64_primaryheader); dstpos += sizeof(*host_primary_header); - u32 src_bgcmds = srctodst32(n64_primary_header->ptr_bgcmds) - ofs; + u32 src_bgcmds = PD_BE32(n64_primary_header->ptr_bgcmds) - ofs; host_primary_header->unused1 = 0; host_primary_header->unused2 = 0; @@ -499,12 +494,12 @@ static u32 convertSection1(u8 *dst, u8 *src, u32 ofs) if (n64_primary_header->ptr_lights) { host_primary_header->ptr_lights = dstpos + ofs; - srcpos = srctodst32(n64_primary_header->ptr_lights) - ofs; + srcpos = PD_BE32(n64_primary_header->ptr_lights) - ofs; convertPrimaryLights(dst, &dstpos, src, &srcpos, src_bgcmds); } host_primary_header->ptr_portals = dstpos + ofs; - srcpos = srctodst32(n64_primary_header->ptr_portals) - ofs; + srcpos = PD_BE32(n64_primary_header->ptr_portals) - ofs; u32 src_portalvtxs, dst_portalvtxs; convertPrimaryPortals(dst, &dstpos, src, &srcpos, &src_portalvtxs, &dst_portalvtxs); @@ -521,7 +516,7 @@ static void convertSection2TextureNums(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpo int count = srclen / sizeof(u16); for (int i = 0; i < count; i++) { - dst_ids[i] = srctodst16(src_ids[i]); + dst_ids[i] = PD_BE16(src_ids[i]); } *srcpos += srclen; @@ -534,12 +529,12 @@ static void convertSection3Bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) s16 *dst_bboxes = (s16 *) &dst[*dstpos]; for (int i = 0; i < m_NumRooms; i++) { - dst_bboxes[i * 6 + 0] = srctodst16(src_bboxes[i * 6 + 0]); - dst_bboxes[i * 6 + 1] = srctodst16(src_bboxes[i * 6 + 1]); - dst_bboxes[i * 6 + 2] = srctodst16(src_bboxes[i * 6 + 2]); - dst_bboxes[i * 6 + 3] = srctodst16(src_bboxes[i * 6 + 3]); - dst_bboxes[i * 6 + 4] = srctodst16(src_bboxes[i * 6 + 4]); - dst_bboxes[i * 6 + 5] = srctodst16(src_bboxes[i * 6 + 5]); + dst_bboxes[i * 6 + 0] = PD_BE16(src_bboxes[i * 6 + 0]); + dst_bboxes[i * 6 + 1] = PD_BE16(src_bboxes[i * 6 + 1]); + dst_bboxes[i * 6 + 2] = PD_BE16(src_bboxes[i * 6 + 2]); + dst_bboxes[i * 6 + 3] = PD_BE16(src_bboxes[i * 6 + 3]); + dst_bboxes[i * 6 + 4] = PD_BE16(src_bboxes[i * 6 + 4]); + dst_bboxes[i * 6 + 5] = PD_BE16(src_bboxes[i * 6 + 5]); } *srcpos += sizeof(s16) * 6 * (m_NumRooms - 1); diff --git a/port/src/preprocess/filelang.c b/port/src/preprocess/filelang.c index f9fd434ad..841dbffe1 100644 --- a/port/src/preprocess/filelang.c +++ b/port/src/preprocess/filelang.c @@ -2,9 +2,7 @@ #include #include -#include "common.h" -#include "romdata.h" -#include "system.h" +#include "preprocess/common.h" static int getNextNonZero(u8 *src, u32 offset, size_t len) { @@ -13,7 +11,7 @@ static int getNextNonZero(u8 *src, u32 offset, size_t len) while (ptr < end) { if (*ptr != 0) { - return srctoh32(*ptr); + return PD_BE32(*ptr); } ptr++; @@ -37,7 +35,7 @@ u32 convertLangFile(u8 *dst, u8 *src, size_t srclen) { // Convert it u32 *src_offsets = (u32 *) src; - size_t src_ptr_table_len = srctoh32(src_offsets[0]); + size_t src_ptr_table_len = PD_BE32(src_offsets[0]); size_t src_str_table_len = srclen - src_ptr_table_len; int num_strings = getNumStrings(src, srclen); size_t dst_ptr_table_len = num_strings * sizeof(uintptr_t); @@ -48,11 +46,11 @@ u32 convertLangFile(u8 *dst, u8 *src, size_t srclen) uintptr_t *dst_offsets = (uintptr_t *) dst; for (int i = 0; i < num_strings; i++) { - u32 src_offset = srctoh32(src_offsets[i]); + u32 src_offset = PD_BE32(src_offsets[i]); if (src_offset) { // Write pointer - dst_offsets[i] = htodst32(cur_dst_offset); + dst_offsets[i] = (cur_dst_offset); // Write string u32 end = getNextNonZero(src, (i + 1) * 4, num_strings * 4); diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index ddab206da..99cf6a619 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -6,9 +6,8 @@ #include "gbi.h" #include "game/texdecompress.h" -#include "common.h" -#include "romdata.h" -#include "system.h" +#include "preprocess/common.h" +#include "preprocess/gbi.h" enum contenttype { /* 0*/ CT_MODELDEF, @@ -402,10 +401,10 @@ static void populateMarkers(u8 *src) switch (marker->type) { case CT_MODELDEF: struct src_modeldef *src_modeldef = src_thing; - int num_texconfigs = srctoh16(src_modeldef->numtexconfigs); - u32 texconfigpos = srctoh32(src_modeldef->ptr_texconfigs); - set_marker(srctoh32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); + int num_texconfigs = PD_BE16(src_modeldef->numtexconfigs); + u32 texconfigpos = PD_BE32(src_modeldef->ptr_texconfigs); + set_marker(PD_BE32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); for (int i = 0; i < num_texconfigs; i++) { set_marker(texconfigpos + sizeof(struct src_texconfig) * i, CT_TEXCONFIG, marker->src_offset); @@ -413,26 +412,26 @@ static void populateMarkers(u8 *src) break; case CT_NODE: struct src_modelnode *src_node = src_thing; - u32 node_type = srctoh16(src_node->type) & 0xff; - set_marker(srctoh32(src_node->ptr_rodata), m_NodeTypeToContentType[node_type], marker->src_offset); - set_marker(srctoh32(src_node->ptr_parent), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_node->ptr_next), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_node->ptr_prev), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_node->ptr_child), CT_NODE, marker->src_offset); + u32 node_type = PD_BE16(src_node->type) & 0xff; + set_marker(PD_BE32(src_node->ptr_rodata), m_NodeTypeToContentType[node_type], marker->src_offset); + set_marker(PD_BE32(src_node->ptr_parent), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_node->ptr_next), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_node->ptr_prev), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_node->ptr_child), CT_NODE, marker->src_offset); break; case CT_TEXCONFIG: struct src_texconfig *src_texconfig = src_thing; - if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { - set_marker(srctoh32(src_texconfig->ptr), CT_TEXDATA, marker->src_offset); + if ((PD_BE32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { + set_marker(PD_BE32(src_texconfig->ptr), CT_TEXDATA, marker->src_offset); } break; case CT_PARTS: struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; u32 *src_parts = (u32 *) src_thing; - int num_parts = srctoh16(src_modeldef2->numparts); + int num_parts = PD_BE16(src_modeldef2->numparts); for (int i = 0; i < num_parts; i++) { - set_marker(srctoh32(src_parts[i]), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_parts[i]), CT_NODE, marker->src_offset); } break; case CT_RODATA_CHRINFO: @@ -441,31 +440,31 @@ static void populateMarkers(u8 *src) break; case CT_RODATA_GUNDL: struct src_rodata_gundl *src_gundl = src_thing; - set_marker(srctoh32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); - set_marker(srctoh32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); - set_marker(srctoh32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); + set_marker(PD_BE32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); + set_marker(PD_BE32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); + set_marker(PD_BE32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); break; case CT_RODATA_DISTANCE: struct src_rodata_distance *src_dist = src_thing; - set_marker(srctoh32(src_dist->ptr_target), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_dist->ptr_target), CT_NODE, marker->src_offset); break; case CT_RODATA_REORDER: struct src_rodata_reorder *src_reorder = src_thing; - set_marker(srctoh32(src_reorder->ptr_node_unk18), CT_NODE, marker->src_offset); - set_marker(srctoh32(src_reorder->ptr_node_unk1c), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_reorder->ptr_node_unk18), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_reorder->ptr_node_unk1c), CT_NODE, marker->src_offset); break; case CT_RODATA_CHRGUNFIRE: struct src_rodata_chrgunfire *src_chrgunfire = src_thing; - set_marker(srctoh32(src_chrgunfire->ptr_texture), CT_TEXCONFIG, marker->src_offset); + set_marker(PD_BE32(src_chrgunfire->ptr_texture), CT_TEXCONFIG, marker->src_offset); break; case CT_RODATA_TOGGLE: struct src_rodata_toggle *src_toggle = src_thing; - set_marker(srctoh32(src_toggle->ptr_target), CT_NODE, marker->src_offset); + set_marker(PD_BE32(src_toggle->ptr_target), CT_NODE, marker->src_offset); break; case CT_RODATA_STARGUNFIRE: struct src_rodata_stargunfire *src_stargunfire = src_thing; - colstart = srctoh32(src_stargunfire->unk00)*4*(sizeof(s16) * 6); - u32 vtxstart = srctoh32(src_stargunfire->ptr_vertices); + colstart = PD_BE32(src_stargunfire->unk00)*4*(sizeof(s16) * 6); + u32 vtxstart = PD_BE32(src_stargunfire->ptr_vertices); u32 vtxend = vtxstart + colstart; colstart = ALIGN8(vtxstart + colstart); set_marker(vtxstart, CT_VTXCOL4, marker->src_offset); @@ -473,14 +472,14 @@ static void populateMarkers(u8 *src) set_marker(vtxend, CT_SKIP, marker->src_offset); } set_marker(colstart, CT_VTXCOL, marker->src_offset); - set_marker(srctoh32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); + set_marker(PD_BE32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); break; case CT_RODATA_DL: struct src_rodata_dl *src_dl = src_thing; - set_marker(srctoh32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); - set_marker(srctoh32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); - set_marker(srctoh32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); - set_marker(srctoh32(src_dl->ptr_vertices), CT_VTXCOL, marker->src_offset); + set_marker(PD_BE32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); + set_marker(PD_BE32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); + set_marker(PD_BE32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); + set_marker(PD_BE32(src_dl->ptr_vertices), CT_VTXCOL, marker->src_offset); break; case CT_TEXDATA: case CT_VTXCOL: @@ -526,7 +525,7 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) u32 src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; u32 src_len = src_end - marker->src_offset; - dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].before); + dstpos = PD_ALIGN(dstpos, m_AlignConfigs[marker->type].before); marker->dst_offset = dstpos; void *dst_thing = &dst[dstpos]; @@ -535,18 +534,18 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) case CT_MODELDEF: struct src_modeldef *src_modeldef = src_thing; struct dst_modeldef *dst_modeldef = dst_thing; - dst_modeldef->ptr_skel = srctodst32(src_modeldef->ptr_skel); - dst_modeldef->numparts = srctodst16(src_modeldef->numparts); - dst_modeldef->nummatrices = srctodst16(src_modeldef->nummatrices); - dst_modeldef->scale = srctodst32(src_modeldef->scale); - dst_modeldef->rwdatalen = srctodst16(src_modeldef->rwdatalen); - dst_modeldef->numtexconfigs = srctodst16(src_modeldef->numtexconfigs); + dst_modeldef->ptr_skel = PD_BE32(src_modeldef->ptr_skel); + dst_modeldef->numparts = PD_BE16(src_modeldef->numparts); + dst_modeldef->nummatrices = PD_BE16(src_modeldef->nummatrices); + dst_modeldef->scale = PD_BE32(src_modeldef->scale); + dst_modeldef->rwdatalen = PD_BE16(src_modeldef->rwdatalen); + dst_modeldef->numtexconfigs = PD_BE16(src_modeldef->numtexconfigs); dstpos += sizeof(*dst_modeldef); break; case CT_NODE: struct src_modelnode *src_node = src_thing; struct dst_modelnode *dst_node = dst_thing; - dst_node->type = srctodst16(src_node->type); + dst_node->type = PD_BE16(src_node->type); dstpos += sizeof(*dst_node); break; case CT_TEXCONFIG: @@ -554,8 +553,8 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) struct dst_texconfig *dst_texconfig = dst_thing; while (src_len >= sizeof(*src_texconfig)) { - if ((srctoh32(src_texconfig->ptr) & 0xff000000) != 0x05000000) { - dst_texconfig->ptr = srctodst32(src_texconfig->ptr); + if ((PD_BE32(src_texconfig->ptr) & 0xff000000) != 0x05000000) { + dst_texconfig->ptr = PD_BE32(src_texconfig->ptr); } dst_texconfig->width = src_texconfig->width; @@ -581,12 +580,12 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; u32 *src_parts = (u32 *) src_thing; uintptr_t *dst_parts = (uintptr_t *) dst_thing; - int num_parts = srctoh16(src_modeldef2->numparts); + int num_parts = PD_BE16(src_modeldef2->numparts); u16 *src_nums = (u16 *) &src_parts[num_parts]; u16 *dst_nums = (u16 *) &dst_parts[num_parts]; for (int i = 0; i < num_parts; i++) { - dst_nums[i] = srctodst16(src_nums[i]); + dst_nums[i] = PD_BE16(src_nums[i]); } dstpos += num_parts * sizeof(uintptr_t) + num_parts * sizeof(u16); if (num_parts) { @@ -606,18 +605,18 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) if (parent->type == CT_RODATA_GUNDL) { struct src_rodata_gundl *src_rodata = (struct src_rodata_gundl *) &src[parent->src_offset]; struct dst_rodata_gundl *dst_rodata = (struct dst_rodata_gundl *) &dst[parent->dst_offset]; - src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + src_vtx = PD_BE32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = (dst_rodata->ptr_vertices) & 0x00ffffff; } else if (parent->type == CT_RODATA_STARGUNFIRE) { struct src_rodata_stargunfire *src_rodata = (struct src_rodata_stargunfire *) &src[parent->src_offset]; struct dst_rodata_stargunfire *dst_rodata = (struct dst_rodata_stargunfire *) &dst[parent->dst_offset]; - src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + src_vtx = PD_BE32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = (dst_rodata->ptr_vertices) & 0x00ffffff; } else if (parent->type == CT_RODATA_DL) { struct src_rodata_dl *src_rodata = (struct src_rodata_dl *) &src[parent->src_offset]; struct dst_rodata_dl *dst_rodata = (struct dst_rodata_dl *) &dst[parent->dst_offset]; - src_vtx = srctoh32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = dsttoh32(dst_rodata->ptr_vertices) & 0x00ffffff; + src_vtx = PD_BE32(src_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = (dst_rodata->ptr_vertices) & 0x00ffffff; } dstpos = gbiConvertGdl(dst, dstpos, src, marker->src_offset, 0); @@ -625,127 +624,127 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) case CT_RODATA_CHRINFO: struct generic_rodata_chrinfo *src_chrinfo = src_thing; struct generic_rodata_chrinfo *dst_chrinfo = dst_thing; - dst_chrinfo->animpart = srctodst16(src_chrinfo->animpart); - dst_chrinfo->mtxindex = srctodst16(src_chrinfo->mtxindex); - dst_chrinfo->unk04 = srctodst32(src_chrinfo->unk04); - dst_chrinfo->rwdataindex = srctodst16(src_chrinfo->rwdataindex); + dst_chrinfo->animpart = PD_BE16(src_chrinfo->animpart); + dst_chrinfo->mtxindex = PD_BE16(src_chrinfo->mtxindex); + dst_chrinfo->unk04 = PD_BE32(src_chrinfo->unk04); + dst_chrinfo->rwdataindex = PD_BE16(src_chrinfo->rwdataindex); dstpos += sizeof(*dst_chrinfo); break; case CT_RODATA_POSITION: struct generic_rodata_position *src_position = src_thing; struct generic_rodata_position *dst_position = dst_thing; - dst_position->pos[0] = srctodst32(src_position->pos[0]); - dst_position->pos[1] = srctodst32(src_position->pos[1]); - dst_position->pos[2] = srctodst32(src_position->pos[2]); - dst_position->part = srctodst16(src_position->part); - dst_position->mtxindexes[0] = srctodst16(src_position->mtxindexes[0]); - dst_position->mtxindexes[1] = srctodst16(src_position->mtxindexes[1]); - dst_position->mtxindexes[2] = srctodst16(src_position->mtxindexes[2]); - dst_position->drawdist = srctodst32(src_position->drawdist); + dst_position->pos[0] = PD_BE32(src_position->pos[0]); + dst_position->pos[1] = PD_BE32(src_position->pos[1]); + dst_position->pos[2] = PD_BE32(src_position->pos[2]); + dst_position->part = PD_BE16(src_position->part); + dst_position->mtxindexes[0] = PD_BE16(src_position->mtxindexes[0]); + dst_position->mtxindexes[1] = PD_BE16(src_position->mtxindexes[1]); + dst_position->mtxindexes[2] = PD_BE16(src_position->mtxindexes[2]); + dst_position->drawdist = PD_BE32(src_position->drawdist); dstpos += sizeof(*dst_position); break; case CT_RODATA_GUNDL: struct src_rodata_gundl *src_gundl = src_thing; struct dst_rodata_gundl *dst_gundl = dst_thing; dst_gundl->ptr_vertices = 0; - dst_gundl->numvertices = srctodst16(src_gundl->numvertices); - dst_gundl->unk12 = srctodst16(src_gundl->unk12); + dst_gundl->numvertices = PD_BE16(src_gundl->numvertices); + dst_gundl->unk12 = PD_BE16(src_gundl->unk12); dstpos += sizeof(*dst_gundl); break; case CT_RODATA_DISTANCE: struct src_rodata_distance *src_dist = src_thing; struct dst_rodata_distance *dst_dist = dst_thing; - dst_dist->near = srctodst32(src_dist->near); - dst_dist->far = srctodst32(src_dist->far); - dst_dist->rwdataindex = srctodst16(src_dist->rwdataindex); + dst_dist->near = PD_BE32(src_dist->near); + dst_dist->far = PD_BE32(src_dist->far); + dst_dist->rwdataindex = PD_BE16(src_dist->rwdataindex); dstpos += sizeof(*dst_dist); break; case CT_RODATA_REORDER: struct src_rodata_reorder *src_reorder = src_thing; struct dst_rodata_reorder *dst_reorder = dst_thing; - dst_reorder->unk00 = srctodst32(src_reorder->unk00); - dst_reorder->unk04 = srctodst32(src_reorder->unk04); - dst_reorder->unk08 = srctodst32(src_reorder->unk08); - dst_reorder->unk0c[0] = srctodst32(src_reorder->unk0c[0]); - dst_reorder->unk0c[1] = srctodst32(src_reorder->unk0c[1]); - dst_reorder->unk0c[2] = srctodst32(src_reorder->unk0c[2]); - dst_reorder->side = srctodst16(src_reorder->side); - dst_reorder->rwdataindex = srctodst16(src_reorder->rwdataindex); + dst_reorder->unk00 = PD_BE32(src_reorder->unk00); + dst_reorder->unk04 = PD_BE32(src_reorder->unk04); + dst_reorder->unk08 = PD_BE32(src_reorder->unk08); + dst_reorder->unk0c[0] = PD_BE32(src_reorder->unk0c[0]); + dst_reorder->unk0c[1] = PD_BE32(src_reorder->unk0c[1]); + dst_reorder->unk0c[2] = PD_BE32(src_reorder->unk0c[2]); + dst_reorder->side = PD_BE16(src_reorder->side); + dst_reorder->rwdataindex = PD_BE16(src_reorder->rwdataindex); dstpos += sizeof(*dst_reorder); break; case CT_RODATA_BBOX: struct generic_rodata_bbox *src_bbox = src_thing; struct generic_rodata_bbox *dst_bbox = dst_thing; - dst_bbox->hitpart = srctodst32(src_bbox->hitpart); - dst_bbox->bbox[0] = srctodst32(src_bbox->bbox[0]); - dst_bbox->bbox[1] = srctodst32(src_bbox->bbox[1]); - dst_bbox->bbox[2] = srctodst32(src_bbox->bbox[2]); - dst_bbox->bbox[3] = srctodst32(src_bbox->bbox[3]); - dst_bbox->bbox[4] = srctodst32(src_bbox->bbox[4]); - dst_bbox->bbox[5] = srctodst32(src_bbox->bbox[5]); + dst_bbox->hitpart = PD_BE32(src_bbox->hitpart); + dst_bbox->bbox[0] = PD_BE32(src_bbox->bbox[0]); + dst_bbox->bbox[1] = PD_BE32(src_bbox->bbox[1]); + dst_bbox->bbox[2] = PD_BE32(src_bbox->bbox[2]); + dst_bbox->bbox[3] = PD_BE32(src_bbox->bbox[3]); + dst_bbox->bbox[4] = PD_BE32(src_bbox->bbox[4]); + dst_bbox->bbox[5] = PD_BE32(src_bbox->bbox[5]); dstpos += sizeof(*dst_bbox); break; case CT_RODATA_CHRGUNFIRE: struct src_rodata_chrgunfire *src_chrgunfire = src_thing; struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; - dst_chrgunfire->pos[0] = srctodst32(src_chrgunfire->pos[0]); - dst_chrgunfire->pos[1] = srctodst32(src_chrgunfire->pos[1]); - dst_chrgunfire->pos[2] = srctodst32(src_chrgunfire->pos[2]); - dst_chrgunfire->dim[0] = srctodst32(src_chrgunfire->dim[0]); - dst_chrgunfire->dim[1] = srctodst32(src_chrgunfire->dim[1]); - dst_chrgunfire->dim[2] = srctodst32(src_chrgunfire->dim[2]); - dst_chrgunfire->unk1c = srctodst32(src_chrgunfire->unk1c); - dst_chrgunfire->rwdataindex = srctodst16(src_chrgunfire->rwdataindex); + dst_chrgunfire->pos[0] = PD_BE32(src_chrgunfire->pos[0]); + dst_chrgunfire->pos[1] = PD_BE32(src_chrgunfire->pos[1]); + dst_chrgunfire->pos[2] = PD_BE32(src_chrgunfire->pos[2]); + dst_chrgunfire->dim[0] = PD_BE32(src_chrgunfire->dim[0]); + dst_chrgunfire->dim[1] = PD_BE32(src_chrgunfire->dim[1]); + dst_chrgunfire->dim[2] = PD_BE32(src_chrgunfire->dim[2]); + dst_chrgunfire->unk1c = PD_BE32(src_chrgunfire->unk1c); + dst_chrgunfire->rwdataindex = PD_BE16(src_chrgunfire->rwdataindex); dst_chrgunfire->ptr_baseaddr = 0; dstpos += sizeof(*dst_chrgunfire); break; case CT_RODATA_11: struct src_rodata_type11 *src_type11 = src_thing; struct dst_rodata_type11 *dst_type11 = dst_thing; - dst_type11->unk00 = srctodst32(src_type11->unk00); - dst_type11->unk04 = srctodst32(src_type11->unk04); - dst_type11->unk08 = srctodst32(src_type11->unk08); - dst_type11->unk0c = srctodst32(src_type11->unk0c); - dst_type11->unk10 = srctodst32(src_type11->unk10); - dst_type11->extra1 = srctodst32(src_type11->extra1); - dst_type11->extra2 = srctodst32(src_type11->extra2); + dst_type11->unk00 = PD_BE32(src_type11->unk00); + dst_type11->unk04 = PD_BE32(src_type11->unk04); + dst_type11->unk08 = PD_BE32(src_type11->unk08); + dst_type11->unk0c = PD_BE32(src_type11->unk0c); + dst_type11->unk10 = PD_BE32(src_type11->unk10); + dst_type11->extra1 = PD_BE32(src_type11->extra1); + dst_type11->extra2 = PD_BE32(src_type11->extra2); dstpos += sizeof(*dst_type11); break; case CT_RODATA_TOGGLE: struct src_rodata_toggle *src_toggle = src_thing; struct dst_rodata_toggle *dst_toggle = dst_thing; - dst_toggle->rwdataindex = srctodst16(src_toggle->rwdataindex); + dst_toggle->rwdataindex = PD_BE16(src_toggle->rwdataindex); dstpos += sizeof(*dst_toggle); break; case CT_RODATA_POSITIONHELD: struct generic_rodata_positionheld *src_posheld = src_thing; struct generic_rodata_positionheld *dst_posheld = dst_thing; - dst_posheld->pos[0] = srctodst32(src_posheld->pos[0]); - dst_posheld->pos[1] = srctodst32(src_posheld->pos[1]); - dst_posheld->pos[2] = srctodst32(src_posheld->pos[2]); - dst_posheld->mtxindex = srctodst16(src_posheld->mtxindex); - dst_posheld->unk10 = srctodst32(src_posheld->unk10); + dst_posheld->pos[0] = PD_BE32(src_posheld->pos[0]); + dst_posheld->pos[1] = PD_BE32(src_posheld->pos[1]); + dst_posheld->pos[2] = PD_BE32(src_posheld->pos[2]); + dst_posheld->mtxindex = PD_BE16(src_posheld->mtxindex); + dst_posheld->unk10 = PD_BE32(src_posheld->unk10); dstpos += sizeof(*dst_posheld); break; case CT_RODATA_STARGUNFIRE: struct src_rodata_stargunfire *src_stargunfire = src_thing; struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; - dst_stargunfire->unk00 = srctodst32(src_stargunfire->unk00); + dst_stargunfire->unk00 = PD_BE32(src_stargunfire->unk00); dstpos += sizeof(*dst_stargunfire); break; case CT_RODATA_HEADSPOT: struct generic_rodata_headspot *src_headspot = src_thing; struct generic_rodata_headspot *dst_headspot = dst_thing; - dst_headspot->rwdataindex = srctodst16(src_headspot->rwdataindex); + dst_headspot->rwdataindex = PD_BE16(src_headspot->rwdataindex); dstpos += sizeof(*dst_headspot); break; case CT_RODATA_DL: struct src_rodata_dl *src_dl = src_thing; struct dst_rodata_dl *dst_dl = dst_thing; - dst_dl->numvertices = srctodst16(src_dl->numvertices); - dst_dl->mcount = srctodst16(src_dl->mcount); - dst_dl->rwdataindex = srctodst16(src_dl->rwdataindex); - dst_dl->numcolours = srctodst16(src_dl->numcolours); + dst_dl->numvertices = PD_BE16(src_dl->numvertices); + dst_dl->mcount = PD_BE16(src_dl->mcount); + dst_dl->rwdataindex = PD_BE16(src_dl->rwdataindex); + dst_dl->numcolours = PD_BE16(src_dl->numcolours); dstpos += sizeof(*dst_dl); break; case CT_RODATA_19: @@ -753,15 +752,15 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) struct generic_rodata_type19 *dst_type19 = dst_thing; u32 *src_vertices = src_thing + sizeof(u32); u32 *dst_vertices = dst_thing + sizeof(u32); - int num_vertices = srctoh32(src_type19->numvertices); + int num_vertices = PD_BE32(src_type19->numvertices); - dst_type19->numvertices = htodst32(num_vertices); + dst_type19->numvertices = (num_vertices); dstpos += sizeof(u32); for (int i = 0; i < num_vertices; i++) { - dst_vertices[i * 3 + 0] = srctodst32(src_vertices[i * 3 + 0]); - dst_vertices[i * 3 + 1] = srctodst32(src_vertices[i * 3 + 1]); - dst_vertices[i * 3 + 2] = srctodst32(src_vertices[i * 3 + 2]); + dst_vertices[i * 3 + 0] = PD_BE32(src_vertices[i * 3 + 0]); + dst_vertices[i * 3 + 1] = PD_BE32(src_vertices[i * 3 + 1]); + dst_vertices[i * 3 + 2] = PD_BE32(src_vertices[i * 3 + 2]); dstpos += sizeof(u32) * 3; } break; @@ -769,7 +768,7 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) break; } - dstpos = ALIGN(dstpos, m_AlignConfigs[marker->type].after); + dstpos = PD_ALIGN(dstpos, m_AlignConfigs[marker->type].after); } return dstpos; @@ -800,37 +799,37 @@ static u8 *relinkPointers(u8 *dst, u8 *src) case CT_MODELDEF: struct src_modeldef *src_modeldef = src_thing; struct dst_modeldef *dst_modeldef = dst_thing; - dst_modeldef->ptr_rootnode = htodst32(resolvePointer(srctoh32(src_modeldef->ptr_rootnode))); - dst_modeldef->ptr_parts = htodst32(resolvePointer(srctoh32(src_modeldef->ptr_parts))); - dst_modeldef->ptr_texconfigs = htodst32(resolvePointer(srctoh32(src_modeldef->ptr_texconfigs))); + dst_modeldef->ptr_rootnode = (resolvePointer(PD_BE32(src_modeldef->ptr_rootnode))); + dst_modeldef->ptr_parts = (resolvePointer(PD_BE32(src_modeldef->ptr_parts))); + dst_modeldef->ptr_texconfigs = (resolvePointer(PD_BE32(src_modeldef->ptr_texconfigs))); break; case CT_NODE: struct src_modelnode *src_node = src_thing; struct dst_modelnode *dst_node = dst_thing; - dst_node->ptr_rodata = htodst32(resolvePointer(srctoh32(src_node->ptr_rodata))); - dst_node->ptr_parent = htodst32(resolvePointer(srctoh32(src_node->ptr_parent))); - dst_node->ptr_next = htodst32(resolvePointer(srctoh32(src_node->ptr_next))); - dst_node->ptr_prev = htodst32(resolvePointer(srctoh32(src_node->ptr_prev))); - dst_node->ptr_child = htodst32(resolvePointer(srctoh32(src_node->ptr_child))); + dst_node->ptr_rodata = (resolvePointer(PD_BE32(src_node->ptr_rodata))); + dst_node->ptr_parent = (resolvePointer(PD_BE32(src_node->ptr_parent))); + dst_node->ptr_next = (resolvePointer(PD_BE32(src_node->ptr_next))); + dst_node->ptr_prev = (resolvePointer(PD_BE32(src_node->ptr_prev))); + dst_node->ptr_child = (resolvePointer(PD_BE32(src_node->ptr_child))); lowestptr = dst_node->ptr_rodata; break; case CT_TEXCONFIG: struct src_texconfig *src_texconfig = src_thing; struct dst_texconfig *dst_texconfig = dst_thing; - if ((srctoh32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { - dst_texconfig->ptr = htodst32(resolvePointer(srctoh32(src_texconfig->ptr))); - gbiAddTexAddr(srctoh32(src_texconfig->ptr), dst_texconfig->ptr); + if ((PD_BE32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { + dst_texconfig->ptr = (resolvePointer(PD_BE32(src_texconfig->ptr))); + gbiAddTexAddr(PD_BE32(src_texconfig->ptr), dst_texconfig->ptr); } break; case CT_PARTS: struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; u32 *src_parts = (u32 *) src_thing; uintptr_t *dst_parts = (uintptr_t *) dst_thing; - int num_parts = srctoh16(src_modeldef2->numparts); + int num_parts = PD_BE16(src_modeldef2->numparts); for (int i = 0; i < num_parts; i++) { - dst_parts[i] = htodst32(resolvePointer(srctoh32(src_parts[i]))); + dst_parts[i] = (resolvePointer(PD_BE32(src_parts[i]))); } break; case CT_RODATA_CHRINFO: @@ -840,13 +839,13 @@ static u8 *relinkPointers(u8 *dst, u8 *src) case CT_RODATA_GUNDL: struct src_rodata_gundl *src_gundl = src_thing; struct dst_rodata_gundl *dst_gundl = dst_thing; - dst_gundl->ptr_opagdl = htodst32(resolvePointer(srctoh32(src_gundl->ptr_opagdl))); - dst_gundl->ptr_xlugdl = htodst32(resolvePointer(srctoh32(src_gundl->ptr_xlugdl))); - dst_gundl->ptr_vertices = htodst32(resolvePointer(srctoh32(src_gundl->ptr_vertices))); + dst_gundl->ptr_opagdl = (resolvePointer(PD_BE32(src_gundl->ptr_opagdl))); + dst_gundl->ptr_xlugdl = (resolvePointer(PD_BE32(src_gundl->ptr_xlugdl))); + dst_gundl->ptr_vertices = (resolvePointer(PD_BE32(src_gundl->ptr_vertices))); gbiConvertVtx(dst, dst_gundl->ptr_vertices & 0x00ffffff, dst_gundl->numvertices); - gbiSetVtx(srctoh32(src_gundl->ptr_vertices), dst_gundl->ptr_vertices); + gbiSetVtx(PD_BE32(src_gundl->ptr_vertices), dst_gundl->ptr_vertices); gbiSetSegment(0x04, dst_gundl->ptr_vertices); gbiGdlRewriteAddrs(dst, dst_gundl->ptr_opagdl); @@ -860,36 +859,36 @@ static u8 *relinkPointers(u8 *dst, u8 *src) case CT_RODATA_DISTANCE: struct src_rodata_distance *src_dist = src_thing; struct dst_rodata_distance *dst_dist = dst_thing; - dst_dist->ptr_target = htodst32(resolvePointer(srctoh32(src_dist->ptr_target))); + dst_dist->ptr_target = (resolvePointer(PD_BE32(src_dist->ptr_target))); break; case CT_RODATA_REORDER: struct src_rodata_reorder *src_reorder = src_thing; struct dst_rodata_reorder *dst_reorder = dst_thing; - dst_reorder->ptr_node_unk18 = htodst32(resolvePointer(srctoh32(src_reorder->ptr_node_unk18))); - dst_reorder->ptr_node_unk1c = htodst32(resolvePointer(srctoh32(src_reorder->ptr_node_unk1c))); + dst_reorder->ptr_node_unk18 = (resolvePointer(PD_BE32(src_reorder->ptr_node_unk18))); + dst_reorder->ptr_node_unk1c = (resolvePointer(PD_BE32(src_reorder->ptr_node_unk1c))); break; case CT_RODATA_CHRGUNFIRE: struct src_rodata_chrgunfire *src_chrgunfire = src_thing; struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; - dst_chrgunfire->ptr_texture = htodst32(resolvePointer(srctoh32(src_chrgunfire->ptr_texture))); - if ((srctoh32(dst_chrgunfire->ptr_texture) & 0xff000000) == 0x05000000) { - gbiAddTexAddr(srctoh32(dst_chrgunfire->ptr_texture), dst_chrgunfire->ptr_texture); + dst_chrgunfire->ptr_texture = (resolvePointer(PD_BE32(src_chrgunfire->ptr_texture))); + if ((PD_BE32(dst_chrgunfire->ptr_texture) & 0xff000000) == 0x05000000) { + gbiAddTexAddr(PD_BE32(dst_chrgunfire->ptr_texture), dst_chrgunfire->ptr_texture); } break; case CT_RODATA_TOGGLE: struct src_rodata_toggle *src_toggle = src_thing; struct dst_rodata_toggle *dst_toggle = dst_thing; - dst_toggle->ptr_target = htodst32(resolvePointer(srctoh32(src_toggle->ptr_target))); + dst_toggle->ptr_target = (resolvePointer(PD_BE32(src_toggle->ptr_target))); break; case CT_RODATA_STARGUNFIRE: struct src_rodata_stargunfire *src_stargunfire = src_thing; struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; - dst_stargunfire->ptr_vertices = htodst32(resolvePointer(srctoh32(src_stargunfire->ptr_vertices))); - dst_stargunfire->ptr_gdl = htodst32(resolvePointer(srctoh32(src_stargunfire->ptr_gdl))); + dst_stargunfire->ptr_vertices = (resolvePointer(PD_BE32(src_stargunfire->ptr_vertices))); + dst_stargunfire->ptr_gdl = (resolvePointer(PD_BE32(src_stargunfire->ptr_gdl))); gbiConvertVtx(dst, dst_stargunfire->ptr_vertices & 0x00ffffff, dst_stargunfire->unk00*4); - gbiSetVtx(srctoh32(src_stargunfire->ptr_vertices), dst_stargunfire->ptr_vertices); + gbiSetVtx(PD_BE32(src_stargunfire->ptr_vertices), dst_stargunfire->ptr_vertices); gbiSetSegment(0x04, dst_stargunfire->ptr_vertices); gbiGdlRewriteAddrs(dst, dst_stargunfire->ptr_gdl); if (dst_stargunfire->ptr_gdl) dst_stargunfire->ptr_gdl |= 1; @@ -899,14 +898,14 @@ static u8 *relinkPointers(u8 *dst, u8 *src) case CT_RODATA_DL: struct src_rodata_dl *src_dl = src_thing; struct dst_rodata_dl *dst_dl = dst_thing; - dst_dl->ptr_opagdl = htodst32(resolvePointer(srctoh32(src_dl->ptr_opagdl))); - dst_dl->ptr_xlugdl = htodst32(resolvePointer(srctoh32(src_dl->ptr_xlugdl))); - dst_dl->ptr_colours = htodst32(resolvePointer(srctoh32(src_dl->ptr_colours))); - dst_dl->ptr_vertices = htodst32(resolvePointer(srctoh32(src_dl->ptr_vertices))); + dst_dl->ptr_opagdl = (resolvePointer(PD_BE32(src_dl->ptr_opagdl))); + dst_dl->ptr_xlugdl = (resolvePointer(PD_BE32(src_dl->ptr_xlugdl))); + dst_dl->ptr_colours = (resolvePointer(PD_BE32(src_dl->ptr_colours))); + dst_dl->ptr_vertices = (resolvePointer(PD_BE32(src_dl->ptr_vertices))); gbiConvertVtx(dst, dst_dl->ptr_vertices & 0x00ffffff, dst_dl->numvertices); - gbiSetVtx(srctoh32(src_dl->ptr_vertices), dst_dl->ptr_vertices); + gbiSetVtx(PD_BE32(src_dl->ptr_vertices), dst_dl->ptr_vertices); gbiSetSegment(0x04, dst_dl->ptr_vertices); gbiGdlRewriteAddrs(dst, dst_dl->ptr_opagdl); gbiGdlRewriteAddrs(dst, dst_dl->ptr_xlugdl); diff --git a/port/src/preprocess/filepads.c b/port/src/preprocess/filepads.c index bcbbe1c69..38ea015ed 100644 --- a/port/src/preprocess/filepads.c +++ b/port/src/preprocess/filepads.c @@ -2,20 +2,9 @@ #include #include -#include "common.h" -#include "romdata.h" -#include "system.h" +#include "preprocess/common.h" -#define PADFLAG_INTPOS 0x0001 -#define PADFLAG_UPALIGNTOX 0x0002 -#define PADFLAG_UPALIGNTOY 0x0004 -#define PADFLAG_UPALIGNTOZ 0x0008 -#define PADFLAG_UPALIGNINVERT 0x0010 -#define PADFLAG_LOOKALIGNTOX 0x0020 -#define PADFLAG_LOOKALIGNTOY 0x0040 -#define PADFLAG_LOOKALIGNTOZ 0x0080 -#define PADFLAG_LOOKALIGNINVERT 0x0100 -#define PADFLAG_HASBBOXDATA 0x0200 +#include "constants.h" struct n64_header { s32 num_pads; @@ -80,16 +69,16 @@ static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) dstpos += num_pads * sizeof(u16); for (int i = 0; i < num_pads; i++) { - srcpos = srctoh16(src_offsets[i]); + srcpos = PD_BE16(src_offsets[i]); - dst_offsets[i] = htodst16(dstpos); + dst_offsets[i] = (dstpos); // Header - u32 n64_padheader = srctoh32(*(u32 *) &src[srcpos]); + u32 n64_padheader = PD_BE32(*(u32 *) &src[srcpos]); struct padheader *host_padheader = (struct padheader *) &dst[dstpos]; u32 flags = (n64_padheader >> 14) & 0x3ffff; - *(u32*)host_padheader = htodst32(n64_padheader); + *(u32*)host_padheader = (n64_padheader); srcpos += sizeof(struct padheader); dstpos += sizeof(struct padheader); @@ -99,9 +88,9 @@ static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) s16 *srcptr = (s16 *) &src[srcpos]; s16 *dstptr = (s16 *) &dst[dstpos]; - dstptr[0] = srctodst16(srcptr[0]); - dstptr[1] = srctodst16(srcptr[1]); - dstptr[2] = srctodst16(srcptr[2]); + dstptr[0] = PD_BE16(srcptr[0]); + dstptr[1] = PD_BE16(srcptr[1]); + dstptr[2] = PD_BE16(srcptr[2]); srcpos += 8; dstpos += 8; @@ -109,9 +98,9 @@ static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) u32 *srcptr = (u32 *) &src[srcpos]; u32 *dstptr = (u32 *) &dst[dstpos]; - dstptr[0] = srctodst32(srcptr[0]); - dstptr[1] = srctodst32(srcptr[1]); - dstptr[2] = srctodst32(srcptr[2]); + dstptr[0] = PD_BE32(srcptr[0]); + dstptr[1] = PD_BE32(srcptr[1]); + dstptr[2] = PD_BE32(srcptr[2]); srcpos += 12; dstpos += 12; @@ -122,9 +111,9 @@ static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) u32 *srcptr = (u32 *) &src[srcpos]; u32 *dstptr = (u32 *) &dst[dstpos]; - dstptr[0] = srctodst32(srcptr[0]); - dstptr[1] = srctodst32(srcptr[1]); - dstptr[2] = srctodst32(srcptr[2]); + dstptr[0] = PD_BE32(srcptr[0]); + dstptr[1] = PD_BE32(srcptr[1]); + dstptr[2] = PD_BE32(srcptr[2]); srcpos += 12; dstpos += 12; @@ -135,9 +124,9 @@ static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) u32 *srcptr = (u32 *) &src[srcpos]; u32 *dstptr = (u32 *) &dst[dstpos]; - dstptr[0] = srctodst32(srcptr[0]); - dstptr[1] = srctodst32(srcptr[1]); - dstptr[2] = srctodst32(srcptr[2]); + dstptr[0] = PD_BE32(srcptr[0]); + dstptr[1] = PD_BE32(srcptr[1]); + dstptr[2] = PD_BE32(srcptr[2]); srcpos += 12; dstpos += 12; @@ -148,12 +137,12 @@ static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) u32 *srcptr = (u32 *) &src[srcpos]; u32 *dstptr = (u32 *) &dst[dstpos]; - dstptr[0] = srctodst32(srcptr[0]); - dstptr[1] = srctodst32(srcptr[1]); - dstptr[2] = srctodst32(srcptr[2]); - dstptr[3] = srctodst32(srcptr[3]); - dstptr[4] = srctodst32(srcptr[4]); - dstptr[5] = srctodst32(srcptr[5]); + dstptr[0] = PD_BE32(srcptr[0]); + dstptr[1] = PD_BE32(srcptr[1]); + dstptr[2] = PD_BE32(srcptr[2]); + dstptr[3] = PD_BE32(srcptr[3]); + dstptr[4] = PD_BE32(srcptr[4]); + dstptr[5] = PD_BE32(srcptr[5]); srcpos += 4 * 6; dstpos += 4 * 6; @@ -177,15 +166,15 @@ static int convertWayPoints(u8 *dst, int dstpos, u8 *src, int srcpos) int n = 0; for (int i = 0; i < num_waypoints; i++) { - host_waypoints[i].padnum = srctodst32(n64_waypoints[i].padnum); - host_waypoints[i].ptr_neighbours = htodst32(dstpos); - host_waypoints[i].groupnum = srctodst32(n64_waypoints[i].groupnum); + host_waypoints[i].padnum = PD_BE32(n64_waypoints[i].padnum); + host_waypoints[i].ptr_neighbours = (dstpos); + host_waypoints[i].groupnum = PD_BE32(n64_waypoints[i].groupnum); host_waypoints[i].step = 0; - u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waypoints[i].ptr_neighbours)]; + u32 *n64_neighbours = (u32 *) &src[PD_BE32(n64_waypoints[i].ptr_neighbours)]; for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { - host_neighbours[n++] = srctodst32(n64_neighbours[j]); + host_neighbours[n++] = PD_BE32(n64_neighbours[j]); dstpos += 4; } @@ -217,13 +206,13 @@ static int convertWayGroups(u8 *dst, int dstpos, u8 *src, int srcpos) int n = 0; for (int i = 0; i < num_waygroups; i++) { - host_waygroups[i].ptr_waypoints = htodst32(dstpos); + host_waygroups[i].ptr_waypoints = (dstpos); host_waygroups[i].step = 0; - u32 *n64_waypoints = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_waypoints)]; + u32 *n64_waypoints = (u32 *) &src[PD_BE32(n64_waygroups[i].ptr_waypoints)]; for (int j = 0; n64_waypoints[j] != 0xffffffff; j++) { - host_waypoints[n++] = srctodst32(n64_waypoints[j]); + host_waypoints[n++] = PD_BE32(n64_waypoints[j]); dstpos += 4; } @@ -241,12 +230,12 @@ static int convertWayGroups(u8 *dst, int dstpos, u8 *src, int srcpos) n = 0; for (int i = 0; i < num_waygroups; i++) { - host_waygroups[i].ptr_neighbours = htodst32(dstpos); + host_waygroups[i].ptr_neighbours = (dstpos); - u32 *n64_neighbours = (u32 *) &src[srctoh32(n64_waygroups[i].ptr_neighbours)]; + u32 *n64_neighbours = (u32 *) &src[PD_BE32(n64_waygroups[i].ptr_neighbours)]; for (int j = 0; n64_neighbours[j] != 0xffffffff; j++) { - host_neighbours[n++] = srctodst32(n64_neighbours[j]); + host_neighbours[n++] = PD_BE32(n64_neighbours[j]); dstpos += 4; } @@ -263,14 +252,14 @@ static int convertCover(u8 *dst, int dstpos, u8 *src, int srcpos, int num_covers struct generic_coverdefinition *host_covers = (struct generic_coverdefinition *) &dst[dstpos]; for (int i = 0; i < num_covers; i++) { - host_covers[i].pos[0] = srctodst32(n64_covers[i].pos[0]); - host_covers[i].pos[1] = srctodst32(n64_covers[i].pos[1]); - host_covers[i].pos[2] = srctodst32(n64_covers[i].pos[2]); - host_covers[i].dir[0] = srctodst32(n64_covers[i].dir[0]); - host_covers[i].dir[1] = srctodst32(n64_covers[i].dir[1]); - host_covers[i].dir[2] = srctodst32(n64_covers[i].dir[2]); - host_covers[i].flags = srctodst16(n64_covers[i].flags); - host_covers[i].unk1a = srctodst16(n64_covers[i].unk1a); + host_covers[i].pos[0] = PD_BE32(n64_covers[i].pos[0]); + host_covers[i].pos[1] = PD_BE32(n64_covers[i].pos[1]); + host_covers[i].pos[2] = PD_BE32(n64_covers[i].pos[2]); + host_covers[i].dir[0] = PD_BE32(n64_covers[i].dir[0]); + host_covers[i].dir[1] = PD_BE32(n64_covers[i].dir[1]); + host_covers[i].dir[2] = PD_BE32(n64_covers[i].dir[2]); + host_covers[i].flags = PD_BE16(n64_covers[i].flags); + host_covers[i].unk1a = PD_BE16(n64_covers[i].unk1a); } dstpos += num_covers * sizeof(struct generic_coverdefinition); @@ -284,10 +273,10 @@ static int convertPadsFile(u8 *dst, u8 *src) struct n64_header *n64_header = (struct n64_header *) src; struct host_header *host_header = (struct host_header *) dst; - int num_pads = srctoh32(n64_header->num_pads); - int num_covers = srctoh32(n64_header->num_covers); - host_header->num_pads = htodst32(num_pads); - host_header->num_covers = htodst32(num_covers); + int num_pads = PD_BE32(n64_header->num_pads); + int num_covers = PD_BE32(n64_header->num_covers); + host_header->num_pads = (num_pads); + host_header->num_covers = (num_covers); dstpos += sizeof(struct host_header); @@ -295,16 +284,16 @@ static int convertPadsFile(u8 *dst, u8 *src) dstpos = convertPads(dst, dstpos, src, sizeof(struct n64_header), num_pads); // Waypoints - host_header->ptr_waypoints = htodst32(dstpos); - dstpos = convertWayPoints(dst, dstpos, src, srctoh32(n64_header->ptr_waypoints)); + host_header->ptr_waypoints = (dstpos); + dstpos = convertWayPoints(dst, dstpos, src, PD_BE32(n64_header->ptr_waypoints)); // Waygroups - host_header->ptr_waygroups = htodst32(dstpos); - dstpos = convertWayGroups(dst, dstpos, src, srctoh32(n64_header->ptr_waygroups)); + host_header->ptr_waygroups = (dstpos); + dstpos = convertWayGroups(dst, dstpos, src, PD_BE32(n64_header->ptr_waygroups)); // Cover - host_header->ptr_cover = htodst32(dstpos); - dstpos = convertCover(dst, dstpos, src, srctoh32(n64_header->ptr_cover), num_covers); + host_header->ptr_cover = (dstpos); + dstpos = convertCover(dst, dstpos, src, PD_BE32(n64_header->ptr_cover), num_covers); return dstpos; } diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index 1ffd46d46..390d1ff11 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -4,20 +4,14 @@ #include "types.h" -#include "assert.h" +#include "preprocess/common.h" +#include "preprocess/setup.h" -#include "common.h" -#include "setups_decl.h" - -#include "romdata.h" -#include "system.h" - - -static inline void convF32(f32 *dst, f32 src) { *(u32*)dst = srctoh32(*(u32*)&src); } -static inline void convU32(u32 *dst, u32 src) { *dst = srctoh32(src); } -static inline void convS32(s32 *dst, s32 src) { *dst = srctoh32(src); } -static inline void convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } -static inline void convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } +static inline void convF32(f32 *dst, f32 src) { *(u32*)dst = PD_BE32(*(u32*)&src); } +static inline void convU32(u32 *dst, u32 src) { *dst = PD_BE32(src); } +static inline void convS32(s32 *dst, s32 src) { *dst = PD_BE32(src); } +static inline void convU16(u16 *dst, u32 src) { *dst = PD_BE16(src); } +static inline void convS16(s16 *dst, s32 src) { *dst = PD_BE16(src); } static inline void cpyByte(u8 *dst, u8 src) { *dst = src; } static inline void convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } static inline void convUnk(u32 x) { assert(0 && "unknown type"); } @@ -40,7 +34,7 @@ static inline void convUnk(u32 x) { assert(0 && "unknown type"); } for (int j = 0; j < ARRAYCOUNT(dst); j++) PD_CONV_VAL(dst[i][j], src[i][j]); \ } -#define PD_CONV_PTR(dst, src, type) dst = (type)srctoh32(src) +#define PD_CONV_PTR(dst, src, type) dst = (type)PD_BE32(src) static u32 obj_size(struct n64_defaultobj *obj) { @@ -165,7 +159,7 @@ void convertDefaultObjHdr(struct defaultobj* dstobj, struct n64_defaultobj* srco u16 *src_unk00_1 = (u16*)&srcobj->extrascale; u8 *src_unk00_2 = (u8*)(src_unk00_1 + 1); - *dst_unk00_1 = srctoh16(*src_unk00_1); + *dst_unk00_1 = PD_BE16(*src_unk00_1); dst_unk00_2[0] = src_unk00_2[0]; dst_unk00_2[1] = src_unk00_2[1]; } @@ -1000,7 +994,7 @@ u32 convertProps(u8* dst, u8* src) type = cmd->type; } - *(u32*)(dst) = htobe32(OBJTYPE_END); + *(u32*)(dst) = PD_BE32(OBJTYPE_END); dst += sizeof(u32); return (u32)(dst - start); @@ -1028,10 +1022,10 @@ static uintptr_t convertIntro(u8 *dst, u8 *src) s32* srcintro = (s32*)src; while (true) { - s32 cmd = dstintro[0] = srctodst32(srcintro[0]); + s32 cmd = dstintro[0] = PD_BE32(srcintro[0]); u8 size = cmd_size[*dstintro]; for (int i = 1; i < size; i++) { - dstintro[i] = srctodst32(srcintro[i]); + dstintro[i] = PD_BE32(srcintro[i]); } dstintro += size; @@ -1073,7 +1067,7 @@ static u32 convertPads(struct path *dstpaths, u8 *dst, u8 *src, u32 dstpos) dstpaths->pads = (s32*)dstpos; while (*pads) { - s32 p = srctoh32(*pads++); + s32 p = PD_BE32(*pads++); *dstpads++ = p; dstpos += sizeof(s32); if (p == -1) break; @@ -1109,14 +1103,14 @@ u32 chraiGetAilistLength(u8 *list); static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) { - resetMarkers(); + ptrReset(); struct n64_ailist *src_ailists = (struct n64_ailist*)&src[src_ofs]; // count the lists and pre-convert the fields int nlists = 0; for (struct n64_ailist *tmp = src_ailists; tmp->ptr_list; tmp++, nlists++) { - tmp->ptr_list = srctodst32(tmp->ptr_list); - tmp->id = srctodst32(tmp->id); + tmp->ptr_list = PD_BE32(tmp->ptr_list); + tmp->id = PD_BE32(tmp->id); } for (struct n64_ailist *ailist = src_ailists; ailist->ptr_list; ailist++) { @@ -1125,19 +1119,19 @@ static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) ailist->ptr_list = dstpos; // multiple ailists can point to the same list, so we need to check if it was already copied - struct ptrmarker *marker = findPtrMarker(src_ptr_list); + struct ptrmarker *marker = ptrFind(src_ptr_list); if (marker) { ailist->ptr_list = marker->ptr_host; continue; } - addMarker(src_ptr_list, dstpos); + ptrAdd(src_ptr_list, dstpos); u8 *list = &src[src_ptr_list]; u32 listsize = chraiGetAilistLength(list); memcpy(dst + dstpos, list, listsize); - dstpos += ALIGN(listsize, 4); + dstpos += PD_ALIGN(listsize, 4); } return dstpos; @@ -1148,10 +1142,10 @@ static int convertSetup(u8 *dst, u8 *src, u32 srclen) struct n64_stagesetup *src_header = (struct n64_stagesetup*)src; struct stagesetup *dst_header = (struct stagesetup*)dst; - src_header->ptr_props = srctodst32(src_header->ptr_props); - src_header->ptr_intro = srctodst32(src_header->ptr_intro); - src_header->ptr_ailists = srctodst32(src_header->ptr_ailists); - src_header->ptr_paths = srctodst32(src_header->ptr_paths); + src_header->ptr_props = PD_BE32(src_header->ptr_props); + src_header->ptr_intro = PD_BE32(src_header->ptr_intro); + src_header->ptr_ailists = PD_BE32(src_header->ptr_ailists); + src_header->ptr_paths = PD_BE32(src_header->ptr_paths); u32 srcpos = sizeof(*src_header); u32 dstpos = sizeof(*dst_header); diff --git a/port/src/preprocess/filetiles.c b/port/src/preprocess/filetiles.c index db0e66f69..d83a7bd55 100644 --- a/port/src/preprocess/filetiles.c +++ b/port/src/preprocess/filetiles.c @@ -2,10 +2,7 @@ #include #include -#include "common.h" -#include "romdata.h" -#include "system.h" - +#include "preprocess/common.h" struct tile { u8 type; @@ -23,7 +20,7 @@ struct tile { u32 convertTiles(u8 *dst, u8 *src, size_t srclen) { - int num_rooms = srctoh32(*(u32 *) src); + int num_rooms = PD_BE32(*(u32 *) src); size_t src_ptr_table_len = (num_rooms + 1) * 4; size_t dst_ptr_table_len = (num_rooms + 1) * sizeof(u32); @@ -32,19 +29,19 @@ u32 convertTiles(u8 *dst, u8 *src, size_t srclen) size_t data_len = srclen - src_ptr_table_len - 4; - *(u32 *) dst = htodst32(num_rooms); + *(u32 *) dst = (num_rooms); u32 *dst_offsets = (u32 *) (dst + sizeof(u32)); u32 cur_dst_offset = dst_ptr_table_len + sizeof(u32); - u32 cur_src_offset = srctoh32(src_offsets[0]); - u32 end_src_offset = srctoh32(src_offsets[num_rooms]); + u32 cur_src_offset = PD_BE32(src_offsets[0]); + u32 end_src_offset = PD_BE32(src_offsets[num_rooms]); int room = 0; while (1) { // Check if this is a new room and write the pointer offset if so - while (room < (num_rooms + 1) && srctoh32(src_offsets[room]) == cur_src_offset) { - dst_offsets[room] = htodst32(cur_dst_offset); + while (room < (num_rooms + 1) && PD_BE32(src_offsets[room]) == cur_src_offset) { + dst_offsets[room] = (cur_dst_offset); room++; } @@ -58,15 +55,15 @@ u32 convertTiles(u8 *dst, u8 *src, size_t srclen) hosttile.type = n64tile->type; hosttile.numvertices = n64tile->numvertices; - hosttile.flags = srctodst16(n64tile->flags); - hosttile.floortype = srctodst16(n64tile->floortype); + hosttile.flags = PD_BE16(n64tile->flags); + hosttile.floortype = PD_BE16(n64tile->floortype); hosttile.xmin = n64tile->xmin; hosttile.ymin = n64tile->ymin; hosttile.zmin = n64tile->zmin; hosttile.xmax = n64tile->xmax; hosttile.ymax = n64tile->ymax; hosttile.zmax = n64tile->zmax; - hosttile.floorcol = srctodst16(n64tile->floorcol); + hosttile.floorcol = PD_BE16(n64tile->floorcol); memcpy(&dst[cur_dst_offset], &hosttile, sizeof(struct tile)); @@ -75,9 +72,9 @@ u32 convertTiles(u8 *dst, u8 *src, size_t srclen) // Write tile vertices for (int i = 0; i < hosttile.numvertices; i++) { - *(s16 *) &dst[cur_dst_offset + 0] = srctodst16(*(s16 *) &src[cur_src_offset + 0]); - *(s16 *) &dst[cur_dst_offset + 2] = srctodst16(*(s16 *) &src[cur_src_offset + 2]); - *(s16 *) &dst[cur_dst_offset + 4] = srctodst16(*(s16 *) &src[cur_src_offset + 4]); + *(s16 *) &dst[cur_dst_offset + 0] = PD_BE16(*(s16 *) &src[cur_src_offset + 0]); + *(s16 *) &dst[cur_dst_offset + 2] = PD_BE16(*(s16 *) &src[cur_src_offset + 2]); + *(s16 *) &dst[cur_dst_offset + 4] = PD_BE16(*(s16 *) &src[cur_src_offset + 4]); cur_dst_offset += 6; cur_src_offset += 6; } diff --git a/port/src/preprocess/util_gbi.c b/port/src/preprocess/gbi.c similarity index 91% rename from port/src/preprocess/util_gbi.c rename to port/src/preprocess/gbi.c index c0b6dfd40..370246511 100644 --- a/port/src/preprocess/util_gbi.c +++ b/port/src/preprocess/gbi.c @@ -1,12 +1,12 @@ #include #include #include -#include "common.h" -#include "gbi.h" +#include -#ifdef FORCE_BE32 -#define HOST_DWORDS_PER_CMD 1 -#elif UINTPTR_MAX == 0xFFFFFFFFFFFFFFFFu +#include "preprocess/common.h" +#include "preprocess/gbi.h" + +#if UINTPTR_MAX > 0xFFFFFFFFu #define HOST_DWORDS_PER_CMD 2 #else #define HOST_DWORDS_PER_CMD 1 @@ -80,11 +80,11 @@ void gbiConvertVtx(u8 *dst, u32 offset, int count) for (int i = 0; i < count; i++) { struct vtx* vtx = &vtxs[i]; - vtx->x = srctodst16(vtx->x); - vtx->y = srctodst16(vtx->y); - vtx->z = srctodst16(vtx->z); - vtx->s = srctodst16(vtx->s); - vtx->t = srctodst16(vtx->t); + vtx->x = PD_BE16(vtx->x); + vtx->y = PD_BE16(vtx->y); + vtx->z = PD_BE16(vtx->z); + vtx->s = PD_BE16(vtx->s); + vtx->t = PD_BE16(vtx->t); } } @@ -181,11 +181,11 @@ u32 gbiConvertGdl(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int segment_cmds) u64 cmd; do { - cmd = srctoh64(*n64_cmd); + cmd = PD_BE64(*n64_cmd); #if HOST_DWORDS_PER_CMD == 2 - host_cmd[0] = htodst64((cmd & 0xffffffff00000000) >> 32); - host_cmd[1] = htodst64(cmd & 0xffffffff); + host_cmd[0] = ((cmd & 0xffffffff00000000) >> 32); + host_cmd[1] = (cmd & 0xffffffff); if (segment_cmds && CMD_IS_SEGMENTED(cmd)) { host_cmd[1] |= 1; diff --git a/port/src/preprocess/preprocess.c b/port/src/preprocess/misc.c similarity index 97% rename from port/src/preprocess/preprocess.c rename to port/src/preprocess/misc.c index dc544161b..f5c4d1c15 100644 --- a/port/src/preprocess/preprocess.c +++ b/port/src/preprocess/misc.c @@ -4,16 +4,14 @@ #include #include #include -#include "platform.h" + #include "data.h" #include "bss.h" #include "game/setuputils.h" #include "game/texdecompress.h" -#include "preprocess.h" -#include "romdata.h" #include "mod.h" -#include "system.h" -#include "common.h" + +#include "preprocess/common.h" u8* preprocessAnimations(u8* data, u32 size, u32* outSize) { diff --git a/port/src/preprocess/segaudio.c b/port/src/preprocess/segaudio.c index 2e03f2f00..eaf5f67c4 100644 --- a/port/src/preprocess/segaudio.c +++ b/port/src/preprocess/segaudio.c @@ -4,8 +4,7 @@ #include "libaudio.h" -#include "common.h" -#include "system.h" +#include "preprocess/common.h" struct generic_adpcm_book { s32 order; @@ -169,10 +168,10 @@ struct host_bankfile { // only proceeds to convert the next item if it's not already converted #define AL_NEXT_ITEM(field, func) { \ - struct ptrmarker *marker = findPtrMarker(srcpos); \ + struct ptrmarker *marker = ptrFind(srcpos); \ if (marker == NULL) { \ - field = htodst32(dstpos); \ - addMarker(srcpos, field); \ + field = (dstpos); \ + ptrAdd(srcpos, field); \ dstpos = func(dst, dstpos, src, srcpos); \ } else { \ field = marker->ptr_host; } \ @@ -185,9 +184,9 @@ static int convertAudioEnvelope(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos += sizeof(struct generic_envelope); - host_envelope->attackTime = srctodst32(n64_envelope->attackTime); - host_envelope->decayTime = srctodst32(n64_envelope->decayTime); - host_envelope->releaseTime = srctodst32(n64_envelope->releaseTime); + host_envelope->attackTime = PD_BE32(n64_envelope->attackTime); + host_envelope->decayTime = PD_BE32(n64_envelope->decayTime); + host_envelope->releaseTime = PD_BE32(n64_envelope->releaseTime); host_envelope->attackVolume = n64_envelope->attackVolume; host_envelope->decayVolume = n64_envelope->decayVolume; @@ -218,12 +217,12 @@ static int convertAudioAdpcmLoop(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos += sizeof(struct generic_adpcm_loop); - host_loop->start = srctodst32(n64_loop->start); - host_loop->end = srctodst32(n64_loop->end); - host_loop->count = srctodst32(n64_loop->count); + host_loop->start = PD_BE32(n64_loop->start); + host_loop->end = PD_BE32(n64_loop->end); + host_loop->count = PD_BE32(n64_loop->count); for (int i = 0; i < ARRAYCOUNT(host_loop->state); i++) { - host_loop->state[i] = srctodst16(n64_loop->state[i]); + host_loop->state[i] = PD_BE16(n64_loop->state[i]); } return dstpos; @@ -236,11 +235,11 @@ static int convertAudioAdpcmBook(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos += sizeof(struct generic_adpcm_book); - host_book->order = srctodst32(n64_book->order); - host_book->npredictors = srctodst32(n64_book->npredictors); + host_book->order = PD_BE32(n64_book->order); + host_book->npredictors = PD_BE32(n64_book->npredictors); for (int i = 0; i < ARRAYCOUNT(host_book->book); i++) { - host_book->book[i] = srctodst16(n64_book->book[i]); + host_book->book[i] = PD_BE16(n64_book->book[i]); } return dstpos; @@ -253,9 +252,9 @@ static int convertAudioRawLoop(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos += sizeof(struct generic_raw_loop); - host_loop->start = srctodst32(n64_loop->start); - host_loop->end = srctodst32(n64_loop->end); - host_loop->count = srctodst32(n64_loop->count); + host_loop->start = PD_BE32(n64_loop->start); + host_loop->end = PD_BE32(n64_loop->end); + host_loop->count = PD_BE32(n64_loop->count); return dstpos; } @@ -267,28 +266,28 @@ static int convertAudioWaveTable(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos += sizeof(struct host_wavetable); - host_wavetable->base = srctodst32(n64_wavetable->base); - host_wavetable->len = srctodst32(n64_wavetable->len); + host_wavetable->base = PD_BE32(n64_wavetable->base); + host_wavetable->len = PD_BE32(n64_wavetable->len); host_wavetable->type = n64_wavetable->type; host_wavetable->flags = n64_wavetable->flags; if (host_wavetable->type == AL_ADPCM_WAVE) { if (n64_wavetable->waveInfo.adpcmWave.loop) { - srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.loop); + srcpos = PD_BE32(n64_wavetable->waveInfo.adpcmWave.loop); AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.loop, convertAudioAdpcmLoop); } else { host_wavetable->waveInfo.adpcmWave.loop = 0; } if (n64_wavetable->waveInfo.adpcmWave.book) { - srcpos = srctoh32(n64_wavetable->waveInfo.adpcmWave.book); + srcpos = PD_BE32(n64_wavetable->waveInfo.adpcmWave.book); AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.book, convertAudioAdpcmBook); } else { host_wavetable->waveInfo.adpcmWave.book = 0; } } else if (host_wavetable->type == AL_RAW16_WAVE) { if (n64_wavetable->waveInfo.rawWave.loop) { - srcpos = srctoh32(n64_wavetable->waveInfo.rawWave.loop); + srcpos = PD_BE32(n64_wavetable->waveInfo.rawWave.loop); AL_NEXT_ITEM(host_wavetable->waveInfo.rawWave.loop, convertAudioRawLoop); } else { host_wavetable->waveInfo.rawWave.loop = 0; @@ -306,21 +305,21 @@ static int convertAudioSound(u8 *dst, int dstpos, u8 *src, int srcpos) dstpos += sizeof(struct host_sound); if (n64_sound->envelope) { - srcpos = srctoh32(n64_sound->envelope); + srcpos = PD_BE32(n64_sound->envelope); AL_NEXT_ITEM(host_sound->envelope, convertAudioEnvelope); } else { host_sound->envelope = 0; } if (n64_sound->keyMap) { - srcpos = srctoh32(n64_sound->keyMap); + srcpos = PD_BE32(n64_sound->keyMap); AL_NEXT_ITEM(host_sound->keyMap, convertAudioKeyMap); } else { host_sound->keyMap = 0; } if (n64_sound->wavetable) { - srcpos = srctoh32(n64_sound->wavetable); + srcpos = PD_BE32(n64_sound->wavetable); AL_NEXT_ITEM(host_sound->wavetable, convertAudioWaveTable); } else { host_sound->wavetable = 0; @@ -337,7 +336,7 @@ static int convertAudioInstrument(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_instrument *n64_instrument = (struct n64_instrument *) &src[srcpos]; struct host_instrument *host_instrument = (struct host_instrument *) &dst[dstpos]; - int soundCount = srctoh16(n64_instrument->soundCount); + int soundCount = PD_BE16(n64_instrument->soundCount); host_instrument->volume = n64_instrument->volume; host_instrument->pan = n64_instrument->pan; @@ -351,13 +350,13 @@ static int convertAudioInstrument(u8 *dst, int dstpos, u8 *src, int srcpos) host_instrument->vibRate = n64_instrument->vibRate; host_instrument->vibDepth = n64_instrument->vibDepth; host_instrument->vibDelay = n64_instrument->vibDelay; - host_instrument->bendRange = srctodst16(n64_instrument->bendRange); - host_instrument->soundCount = htodst16(soundCount); + host_instrument->bendRange = PD_BE16(n64_instrument->bendRange); + host_instrument->soundCount = (soundCount); dstpos = dstpos + sizeof(struct host_instrument) + sizeof(uintptr_t) * (soundCount - 1); for (int i = 0; i < soundCount; i++) { - srcpos = srctoh32(n64_instrument->soundArray[i]); + srcpos = PD_BE32(n64_instrument->soundArray[i]); AL_NEXT_ITEM(host_instrument->soundArray[i], convertAudioSound); } @@ -368,24 +367,24 @@ static int convertAudioBank(u8 *dst, int dstpos, u8 *src, int srcpos) { struct n64_bank *n64_bank = (struct n64_bank *) &src[srcpos]; struct host_bank *host_bank = (struct host_bank *) &dst[dstpos]; - int instCount = srctoh16(n64_bank->instCount); + int instCount = PD_BE16(n64_bank->instCount); - host_bank->instCount = htodst16(instCount); + host_bank->instCount = (instCount); host_bank->flags = n64_bank->flags; host_bank->pad = n64_bank->pad; - host_bank->sampleRate = srctodst32(n64_bank->sampleRate); + host_bank->sampleRate = PD_BE32(n64_bank->sampleRate); dstpos = dstpos + sizeof(struct host_bank) + sizeof(uintptr_t) * (instCount - 1); if (n64_bank->percussion) { - srcpos = srctoh32(n64_bank->percussion); + srcpos = PD_BE32(n64_bank->percussion); AL_NEXT_ITEM(host_bank->percussion, convertAudioInstrument); } else { host_bank->percussion = 0; } for (int i = 0; i < instCount; i++) { - srcpos = srctoh32(n64_bank->instArray[i]); + srcpos = PD_BE32(n64_bank->instArray[i]); AL_NEXT_ITEM(host_bank->instArray[i], convertAudioInstrument); } @@ -396,17 +395,17 @@ static int convertAudioBankFile(u8 *dst, u8 *src) { struct n64_bankfile *n64_bankfile = (struct n64_bankfile *)src; struct host_bankfile *host_bankfile = (struct host_bankfile *)dst; - int bankCount = srctoh16(n64_bankfile->bankCount); + int bankCount = PD_BE16(n64_bankfile->bankCount); - host_bankfile->revision = srctodst16(n64_bankfile->revision); - host_bankfile->bankCount = htodst16(bankCount); + host_bankfile->revision = PD_BE16(n64_bankfile->revision); + host_bankfile->bankCount = (bankCount); u32 dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); for (int i = 0; i < bankCount; i++) { - host_bankfile->bankArray[i] = htodst32(dstpos); - u32 srcpos = srctoh32(n64_bankfile->bankArray[i]); + host_bankfile->bankArray[i] = (dstpos); + u32 srcpos = PD_BE32(n64_bankfile->bankArray[i]); dstpos = convertAudioBank(dst, dstpos, src, srcpos); } @@ -415,7 +414,7 @@ static int convertAudioBankFile(u8 *dst, u8 *src) u8 *preprocessALBankFile(u8 *src, u32 size, u32 *outSize) { - resetMarkers(); + ptrReset(); u32 dstlen = size * 3; u8 *dst = sysMemZeroAlloc(dstlen); diff --git a/port/src/preprocess/segfonts.c b/port/src/preprocess/segfonts.c index e201d21ee..6d37bd532 100644 --- a/port/src/preprocess/segfonts.c +++ b/port/src/preprocess/segfonts.c @@ -3,8 +3,8 @@ #include #include #include -#include "common.h" -#include "system.h" + +#include "preprocess/common.h" struct n64fontchar { u8 index; @@ -71,11 +71,11 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) s32 *dst_kerning_table = (s32 *)dst; for (int i = 0; i < 13 * 13; i++) { - dst_kerning_table[i] = srctodst32(src_kerning_table[i]); + dst_kerning_table[i] = PD_BE32(src_kerning_table[i]); } - u32 src_offset = ALIGN(13 * 13 * 4, sizeof(u32)); - u32 dst_offset = ALIGN(13 * 13 * 4, sizeof(uintptr_t)); + u32 src_offset = PD_ALIGN(13 * 13 * 4, sizeof(u32)); + u32 dst_offset = PD_ALIGN(13 * 13 * 4, sizeof(uintptr_t)); // Character table #if VERSION == VERSION_JPN_FINAL @@ -84,12 +84,12 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) u32 diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); for (int i = 0; i < num_chars; i++) { - dst_char_table[i].index = srctodst16(src_char_table[i].index); + dst_char_table[i].index = PD_BE16(src_char_table[i].index); dst_char_table[i].baseline = src_char_table[i].baseline; dst_char_table[i].height = src_char_table[i].height; dst_char_table[i].width = src_char_table[i].width; - dst_char_table[i].kerningindex = srctodst16(src_char_table[i].kerningindex); - dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? srctodst32(src_char_table[i].pixeldata) + diff : 0; + dst_char_table[i].kerningindex = PD_BE16(src_char_table[i].kerningindex); + dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? PD_BE32(src_char_table[i].pixeldata) + diff : 0; } src_offset += num_chars * sizeof(struct n64fontcharjpn); @@ -104,8 +104,8 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) dst_char_table[i].baseline = src_char_table[i].baseline; dst_char_table[i].height = src_char_table[i].height; dst_char_table[i].width = src_char_table[i].width; - dst_char_table[i].kerningindex = srctodst32(src_char_table[i].kerningindex); - dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? srctodst32(src_char_table[i].pixeldata) + diff : 0; + dst_char_table[i].kerningindex = PD_BE32(src_char_table[i].kerningindex); + dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? PD_BE32(src_char_table[i].pixeldata) + diff : 0; } src_offset += num_chars * sizeof(struct n64fontchar); From 2f221b9a1ea47f344d3f945456588606eb26c331 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 10:49:13 +0100 Subject: [PATCH 71/81] port: 64-bit: fix warnings --- port/src/preprocess/filebg.c | 34 +-------- port/src/preprocess/filemodel.c | 129 ++++++++++++++++---------------- port/src/preprocess/filesetup.c | 26 +++---- port/src/romdata.c | 2 +- 4 files changed, 81 insertions(+), 110 deletions(-) diff --git a/port/src/preprocess/filebg.c b/port/src/preprocess/filebg.c index 3fe50fe9c..31f744ee8 100644 --- a/port/src/preprocess/filebg.c +++ b/port/src/preprocess/filebg.c @@ -427,7 +427,7 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) ptrAdd(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - uintptr_t col_end = numgdls > 0 != 0 ? gdls_addr[0] : infsize; + uintptr_t col_end = (numgdls > 0) ? gdls_addr[0] : infsize; size_t col_len = col_end - curpos_src; memcpy(dst + curpos_dst, src + curpos_src, col_len); @@ -509,38 +509,6 @@ static u32 convertSection1(u8 *dst, u8 *src, u32 ofs) return dstpos; } -static void convertSection2TextureNums(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 srclen) -{ - u16 *src_ids = (u16 *) &src[*srcpos]; - u16 *dst_ids = (u16 *) &dst[*dstpos]; - int count = srclen / sizeof(u16); - - for (int i = 0; i < count; i++) { - dst_ids[i] = PD_BE16(src_ids[i]); - } - - *srcpos += srclen; - *dstpos += srclen; -} - -static void convertSection3Bboxes(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) -{ - s16 *src_bboxes = (s16 *) &src[*srcpos]; - s16 *dst_bboxes = (s16 *) &dst[*dstpos]; - - for (int i = 0; i < m_NumRooms; i++) { - dst_bboxes[i * 6 + 0] = PD_BE16(src_bboxes[i * 6 + 0]); - dst_bboxes[i * 6 + 1] = PD_BE16(src_bboxes[i * 6 + 1]); - dst_bboxes[i * 6 + 2] = PD_BE16(src_bboxes[i * 6 + 2]); - dst_bboxes[i * 6 + 3] = PD_BE16(src_bboxes[i * 6 + 3]); - dst_bboxes[i * 6 + 4] = PD_BE16(src_bboxes[i * 6 + 4]); - dst_bboxes[i * 6 + 5] = PD_BE16(src_bboxes[i * 6 + 5]); - } - - *srcpos += sizeof(s16) * 6 * (m_NumRooms - 1); - *dstpos += sizeof(s16) * 6 * (m_NumRooms - 1); -} - void preprocessBgSection1(u8 *data, u32 size, u32 ofs) { u8 *dst = sysMemZeroAlloc(size); diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index 99cf6a619..46f8e8ea4 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -47,7 +47,7 @@ struct alignconfig { int after; }; -struct alignconfig m_AlignConfigs[] = { +static const struct alignconfig alignConfigs[] = { /* 0*/ { 16, 4 }, /* 1*/ { 4, 4 }, /* 2*/ { 4, 4 }, @@ -73,8 +73,8 @@ struct alignconfig m_AlignConfigs[] = { /*22*/ { 4, 4 } }; -struct marker m_Markers[1024]; -int m_NumMarkers; +static struct marker contentMarkers[1024]; +static int numContentMarkers; struct src_modeldef { u32 ptr_rootnode; @@ -324,18 +324,18 @@ static inline uintptr_t minPtr3(uintptr_t a, uintptr_t b, uintptr_t c) { return minPtr(minPtr(a, b), c); } -static struct marker *find_marker(u32 src_offset) +static struct marker *findMarker(u32 src_offset) { - for (int i = 0; i < m_NumMarkers; i++) { - if (m_Markers[i].src_offset == src_offset) { - return &m_Markers[i]; + for (int i = 0; i < numContentMarkers; i++) { + if (contentMarkers[i].src_offset == src_offset) { + return &contentMarkers[i]; } } return NULL; } -static void set_marker(u32 src_offset, enum contenttype type, u32 parent_src_offset) +static void setMarker(u32 src_offset, enum contenttype type, u32 parent_src_offset) { if (src_offset == 0) { return; @@ -343,21 +343,21 @@ static void set_marker(u32 src_offset, enum contenttype type, u32 parent_src_off src_offset &= 0x00ffffff; - if (find_marker(src_offset)) { + if (findMarker(src_offset)) { return; } - if (m_NumMarkers >= ARRAYCOUNT(m_Markers)) { - sysFatalError("Marker limit exceeded"); + if (numContentMarkers >= ARRAYCOUNT(contentMarkers)) { + sysFatalError("setMarker: marker limit exceeded"); } - m_Markers[m_NumMarkers].src_offset = src_offset; - m_Markers[m_NumMarkers].type = type; - m_Markers[m_NumMarkers].parent_src_offset = parent_src_offset; - m_NumMarkers++; + contentMarkers[numContentMarkers].src_offset = src_offset; + contentMarkers[numContentMarkers].type = type; + contentMarkers[numContentMarkers].parent_src_offset = parent_src_offset; + numContentMarkers++; } -enum contenttype m_NodeTypeToContentType[] = { +static const enum contenttype nodeTypeToContentType[] = { /*0x00*/ -1, /*0x01*/ CT_RODATA_CHRINFO, /*0x02*/ CT_RODATA_POSITION, @@ -388,12 +388,12 @@ enum contenttype m_NodeTypeToContentType[] = { static void populateMarkers(u8 *src) { - m_NumMarkers = 0; + numContentMarkers = 0; - set_marker(0x05000000, CT_MODELDEF, 0); + setMarker(0x05000000, CT_MODELDEF, 0); - for (int i = 0; i < m_NumMarkers; i++) { - struct marker *marker = &m_Markers[i]; + for (int i = 0; i < numContentMarkers; i++) { + struct marker *marker = &contentMarkers[i]; void *src_thing = &src[marker->src_offset]; int numvtx = 0; u32 colstart = 0; @@ -403,26 +403,26 @@ static void populateMarkers(u8 *src) struct src_modeldef *src_modeldef = src_thing; int num_texconfigs = PD_BE16(src_modeldef->numtexconfigs); u32 texconfigpos = PD_BE32(src_modeldef->ptr_texconfigs); - set_marker(PD_BE32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); - set_marker(PD_BE32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); + setMarker(PD_BE32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); for (int i = 0; i < num_texconfigs; i++) { - set_marker(texconfigpos + sizeof(struct src_texconfig) * i, CT_TEXCONFIG, marker->src_offset); + setMarker(texconfigpos + sizeof(struct src_texconfig) * i, CT_TEXCONFIG, marker->src_offset); } break; case CT_NODE: struct src_modelnode *src_node = src_thing; u32 node_type = PD_BE16(src_node->type) & 0xff; - set_marker(PD_BE32(src_node->ptr_rodata), m_NodeTypeToContentType[node_type], marker->src_offset); - set_marker(PD_BE32(src_node->ptr_parent), CT_NODE, marker->src_offset); - set_marker(PD_BE32(src_node->ptr_next), CT_NODE, marker->src_offset); - set_marker(PD_BE32(src_node->ptr_prev), CT_NODE, marker->src_offset); - set_marker(PD_BE32(src_node->ptr_child), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_node->ptr_rodata), nodeTypeToContentType[node_type], marker->src_offset); + setMarker(PD_BE32(src_node->ptr_parent), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_node->ptr_next), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_node->ptr_prev), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_node->ptr_child), CT_NODE, marker->src_offset); break; case CT_TEXCONFIG: struct src_texconfig *src_texconfig = src_thing; if ((PD_BE32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { - set_marker(PD_BE32(src_texconfig->ptr), CT_TEXDATA, marker->src_offset); + setMarker(PD_BE32(src_texconfig->ptr), CT_TEXDATA, marker->src_offset); } break; case CT_PARTS: @@ -431,7 +431,7 @@ static void populateMarkers(u8 *src) int num_parts = PD_BE16(src_modeldef2->numparts); for (int i = 0; i < num_parts; i++) { - set_marker(PD_BE32(src_parts[i]), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_parts[i]), CT_NODE, marker->src_offset); } break; case CT_RODATA_CHRINFO: @@ -440,26 +440,26 @@ static void populateMarkers(u8 *src) break; case CT_RODATA_GUNDL: struct src_rodata_gundl *src_gundl = src_thing; - set_marker(PD_BE32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); - set_marker(PD_BE32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); - set_marker(PD_BE32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); + setMarker(PD_BE32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); + setMarker(PD_BE32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); + setMarker(PD_BE32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); break; case CT_RODATA_DISTANCE: struct src_rodata_distance *src_dist = src_thing; - set_marker(PD_BE32(src_dist->ptr_target), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_dist->ptr_target), CT_NODE, marker->src_offset); break; case CT_RODATA_REORDER: struct src_rodata_reorder *src_reorder = src_thing; - set_marker(PD_BE32(src_reorder->ptr_node_unk18), CT_NODE, marker->src_offset); - set_marker(PD_BE32(src_reorder->ptr_node_unk1c), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_reorder->ptr_node_unk18), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_reorder->ptr_node_unk1c), CT_NODE, marker->src_offset); break; case CT_RODATA_CHRGUNFIRE: struct src_rodata_chrgunfire *src_chrgunfire = src_thing; - set_marker(PD_BE32(src_chrgunfire->ptr_texture), CT_TEXCONFIG, marker->src_offset); + setMarker(PD_BE32(src_chrgunfire->ptr_texture), CT_TEXCONFIG, marker->src_offset); break; case CT_RODATA_TOGGLE: struct src_rodata_toggle *src_toggle = src_thing; - set_marker(PD_BE32(src_toggle->ptr_target), CT_NODE, marker->src_offset); + setMarker(PD_BE32(src_toggle->ptr_target), CT_NODE, marker->src_offset); break; case CT_RODATA_STARGUNFIRE: struct src_rodata_stargunfire *src_stargunfire = src_thing; @@ -467,19 +467,19 @@ static void populateMarkers(u8 *src) u32 vtxstart = PD_BE32(src_stargunfire->ptr_vertices); u32 vtxend = vtxstart + colstart; colstart = ALIGN8(vtxstart + colstart); - set_marker(vtxstart, CT_VTXCOL4, marker->src_offset); + setMarker(vtxstart, CT_VTXCOL4, marker->src_offset); if (vtxend != colstart) { - set_marker(vtxend, CT_SKIP, marker->src_offset); + setMarker(vtxend, CT_SKIP, marker->src_offset); } - set_marker(colstart, CT_VTXCOL, marker->src_offset); - set_marker(PD_BE32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); + setMarker(colstart, CT_VTXCOL, marker->src_offset); + setMarker(PD_BE32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); break; case CT_RODATA_DL: struct src_rodata_dl *src_dl = src_thing; - set_marker(PD_BE32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); - set_marker(PD_BE32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); - set_marker(PD_BE32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); - set_marker(PD_BE32(src_dl->ptr_vertices), CT_VTXCOL, marker->src_offset); + setMarker(PD_BE32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); + setMarker(PD_BE32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); + setMarker(PD_BE32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); + setMarker(PD_BE32(src_dl->ptr_vertices), CT_VTXCOL, marker->src_offset); break; case CT_TEXDATA: case CT_VTXCOL: @@ -490,27 +490,29 @@ static void populateMarkers(u8 *src) case CT_RODATA_HEADSPOT: case CT_RODATA_19: break; + default: + break; } } } static void sortMarkers(void) { - for (int i = 0; i < m_NumMarkers - 1; i++) { + for (int i = 0; i < numContentMarkers - 1; i++) { u32 min_offset = 0xffffffff; int min_index = -1; - for (int j = i + 1; j < m_NumMarkers; j++) { - if (m_Markers[j].src_offset < min_offset) { - min_offset = m_Markers[j].src_offset; + for (int j = i + 1; j < numContentMarkers; j++) { + if (contentMarkers[j].src_offset < min_offset) { + min_offset = contentMarkers[j].src_offset; min_index = j; } } - if (min_index >= 0 && m_Markers[min_index].src_offset < m_Markers[i].src_offset) { - struct marker tmp = m_Markers[i]; - m_Markers[i] = m_Markers[min_index]; - m_Markers[min_index] = tmp; + if (min_index >= 0 && contentMarkers[min_index].src_offset < contentMarkers[i].src_offset) { + struct marker tmp = contentMarkers[i]; + contentMarkers[i] = contentMarkers[min_index]; + contentMarkers[min_index] = tmp; } } } @@ -519,13 +521,13 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) { u32 dstpos = 0; - for (int i = 0; i < m_NumMarkers; i++) { - struct marker *marker = &m_Markers[i]; + for (int i = 0; i < numContentMarkers; i++) { + struct marker *marker = &contentMarkers[i]; void *src_thing = &src[marker->src_offset]; - u32 src_end = i < m_NumMarkers - 1 ? m_Markers[i + 1].src_offset : src_file_len; + u32 src_end = i < numContentMarkers - 1 ? contentMarkers[i + 1].src_offset : src_file_len; u32 src_len = src_end - marker->src_offset; - dstpos = PD_ALIGN(dstpos, m_AlignConfigs[marker->type].before); + dstpos = PD_ALIGN(dstpos, alignConfigs[marker->type].before); marker->dst_offset = dstpos; void *dst_thing = &dst[dstpos]; @@ -598,7 +600,7 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) dstpos += src_len; break; case CT_GDL: - struct marker *parent = find_marker(marker->parent_src_offset); + struct marker *parent = findMarker(marker->parent_src_offset); u32 src_vtx; u32 dst_vtx; @@ -768,7 +770,7 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) break; } - dstpos = PD_ALIGN(dstpos, m_AlignConfigs[marker->type].after); + dstpos = PD_ALIGN(dstpos, alignConfigs[marker->type].after); } return dstpos; @@ -780,7 +782,7 @@ static u32 resolvePointer(u32 src_offset) return 0; } - struct marker *marker = find_marker(src_offset & 0x00ffffff); + struct marker *marker = findMarker(src_offset & 0x00ffffff); return marker ? (0x05000000 | marker->dst_offset) : 0; } @@ -788,8 +790,8 @@ static u8 *relinkPointers(u8 *dst, u8 *src) { uintptr_t textures_end = 0; - for (int i = 0; i < m_NumMarkers; i++) { - struct marker *marker = &m_Markers[i]; + for (int i = 0; i < numContentMarkers; i++) { + struct marker *marker = &contentMarkers[i]; void *src_thing = &src[marker->src_offset]; void *dst_thing = &dst[marker->dst_offset]; @@ -925,6 +927,7 @@ static u8 *relinkPointers(u8 *dst, u8 *src) case CT_RODATA_POSITIONHELD: case CT_RODATA_HEADSPOT: case CT_RODATA_19: + default: break; } diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index 390d1ff11..30b5d4da6 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -34,7 +34,7 @@ static inline void convUnk(u32 x) { assert(0 && "unknown type"); } for (int j = 0; j < ARRAYCOUNT(dst); j++) PD_CONV_VAL(dst[i][j], src[i][j]); \ } -#define PD_CONV_PTR(dst, src, type) dst = (type)PD_BE32(src) +#define PD_CONV_PTR(dst, src, type) dst = (type)(uintptr_t)PD_BE32(src) static u32 obj_size(struct n64_defaultobj *obj) { @@ -1061,10 +1061,10 @@ static u32 convertPaths(u8 *dst, u8 *src) static u32 convertPads(struct path *dstpaths, u8 *dst, u8 *src, u32 dstpos) { u32 start = dstpos; - s32 *dstpads = (s32*)&dst[dstpos]; + s32 *dstpads = (s32 *)&dst[dstpos]; while (dstpaths->pads) { - s32 *pads = (s32*)&src[(uintptr_t)dstpaths->pads]; - dstpaths->pads = (s32*)dstpos; + s32 *pads = (s32 *)&src[(uintptr_t)dstpaths->pads]; + dstpaths->pads = (s32 *)(uintptr_t)dstpos; while (*pads) { s32 p = PD_BE32(*pads++); @@ -1081,12 +1081,12 @@ static u32 convertPads(struct path *dstpaths, u8 *dst, u8 *src, u32 dstpos) static u32 convertAiLists(u8* dst, u8* src) { - struct n64_ailist* srcailist = (struct n64_ailist*)src; - struct ailist* dstailist = (struct ailist*)dst; + struct n64_ailist* srcailist = (struct n64_ailist *)src; + struct ailist* dstailist = (struct ailist *)dst; while (true) { // at this point these fields are already converted, so we just assign - dstailist->list = (u8*)srcailist->ptr_list; + dstailist->list = (u8 *)(uintptr_t)srcailist->ptr_list; dstailist->id = srcailist->id; @@ -1096,10 +1096,10 @@ static u32 convertAiLists(u8* dst, u8* src) srcailist++; } - return (u32)((u8*)dstailist - dst + sizeof(uintptr_t)); + return (u32)((u8 *)dstailist - dst + sizeof(uintptr_t)); } -u32 chraiGetAilistLength(u8 *list); +extern u32 chraiGetAilistLength(u8 *list); static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) { @@ -1151,22 +1151,22 @@ static int convertSetup(u8 *dst, u8 *src, u32 srclen) u32 dstpos = sizeof(*dst_header); srcpos = src_header->ptr_props; - dst_header->props = (u32*) dstpos; + dst_header->props = (u32 *)(uintptr_t)dstpos; dstpos += convertProps(&dst[dstpos], &src[srcpos]); srcpos = src_header->ptr_intro; - dst_header->intro = (s32*)dstpos; + dst_header->intro = (s32 *)(uintptr_t)dstpos; dstpos += convertIntro(&dst[dstpos], &src[srcpos]); // write the lists bytecodes before the ailists entries dstpos = convertLists(dst, src, dstpos, src_header->ptr_ailists); srcpos = src_header->ptr_ailists; - dst_header->ailists = (struct ailist*)dstpos; + dst_header->ailists = (struct ailist *)(uintptr_t)dstpos; dstpos += convertAiLists(&dst[dstpos], &src[srcpos]); srcpos = src_header->ptr_paths; - dst_header->paths = (struct path*) dstpos; + dst_header->paths = (struct path *)(uintptr_t)dstpos; dstpos += convertPaths(&dst[dstpos], &src[srcpos]); dstpos += convertPads((struct path*)&dst[(uintptr_t)dst_header->paths], dst, src, dstpos); diff --git a/port/src/romdata.c b/port/src/romdata.c index 455659110..a8e3f5bb4 100644 --- a/port/src/romdata.c +++ b/port/src/romdata.c @@ -264,7 +264,7 @@ static inline void romdataInitSegment(struct romfile *seg) seg->size = seg[1].data - seg->data; } else { // this is the last segment, calculate based on rom size - seg->size = (u8 *)g_RomFileSize - seg->data; + seg->size = (uintptr_t)g_RomFileSize - (uintptr_t)seg->data; } } From 163dbf9495dd67b6d7f6a739b489fafdac27553e Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 13:13:42 +0100 Subject: [PATCH 72/81] port: 64-bit: get rid of host_ structs; further cleanup --- port/include/preprocess.h | 5 +- port/include/preprocess/common.h | 4 +- port/include/preprocess/setup.h | 1 - port/src/preprocess/filebg.c | 171 ++++------- port/src/preprocess/filemodel.c | 491 +++++++++++-------------------- port/src/preprocess/filepads.c | 66 ++--- port/src/preprocess/filesetup.c | 23 +- port/src/preprocess/filetiles.c | 2 +- port/src/preprocess/gbi.c | 42 +-- port/src/preprocess/misc.c | 43 +-- port/src/preprocess/segaudio.c | 232 +++++---------- port/src/preprocess/segfonts.c | 56 ++-- src/include/types.h | 3 + src/lib/snd.c | 2 +- 14 files changed, 395 insertions(+), 746 deletions(-) diff --git a/port/include/preprocess.h b/port/include/preprocess.h index 6c0fd609b..450a641fc 100644 --- a/port/include/preprocess.h +++ b/port/include/preprocess.h @@ -3,14 +3,14 @@ #include -typedef u8* (*preprocessfunc)(u8 *data, u32 size, u32 *outSize); +typedef u8 *(*preprocessfunc)(u8 *data, u32 size, u32 *outSize); u8* preprocessAnimations(u8 *data, u32 size, u32 *outSize); u8* preprocessMpConfigs(u8 *data, u32 size, u32 *outSize); u8* preprocessFont(u8 *data, u32 size, u32 *outSize); u8* preprocessJpnFont(u8 *data, u32 size, u32 *outSize); u8* preprocessALBankFile(u8 *data, u32 size, u32 *outSize); -void preprocessALCMidiHdr(u8 *data, u32 size); +u8 *preprocessALCMidiHdr(u8 *data, u32 size, u32 *outSize); u8* preprocessSequences(u8 *data, u32 size, u32 *outSize); u8* preprocessTexturesList(u8 *data, u32 size, u32 *outSize); @@ -20,7 +20,6 @@ void preprocessBgSection3(u8* data, u32 size); void preprocessBgSection1Header(u8 *data, u32 size); void preprocessBgSection2Header(u8 *data, u32 size); void preprocessBgSection3Header(u8 *data, u32 size); -void preprocessBgLights(u8 *data, u32 ofs); u32 preprocessBgRoom(u8* data, u32 size, u32 room_ofs); u8 *preprocessLangFile(u8 *data, u32 size, u32 *outSize); diff --git a/port/include/preprocess/common.h b/port/include/preprocess/common.h index 7ad5c0c09..1927eaef7 100644 --- a/port/include/preprocess/common.h +++ b/port/include/preprocess/common.h @@ -31,7 +31,7 @@ static inline void* swapPtr(void** x) { return (void*)PD_BEPTR((uintptr_t)x); } static inline struct coord swapCrd(struct coord crd) { crd.x = swapF32(crd.x); crd.y = swapF32(crd.y); crd.z = swapF32(crd.z); return crd; } static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } -#define PD_SWAP_VAL(x) x = _Generic((x), \ +#define PD_SWAPPED_VAL(x) _Generic((x), \ f32: swapF32, \ u32: swapU32, \ s32: swapS32, \ @@ -41,6 +41,8 @@ static inline u32 swapUnk(u32 x) { assert(0 && "unknown type"); return x; } default: swapUnk \ )(x) +#define PD_SWAP_VAL(x) x = PD_SWAPPED_VAL(x) + #define PD_SWAP_PTR(x) x = swapPtr((void *)(x)) // ptr marker functions diff --git a/port/include/preprocess/setup.h b/port/include/preprocess/setup.h index f8bcff391..f281410c4 100644 --- a/port/include/preprocess/setup.h +++ b/port/include/preprocess/setup.h @@ -14,7 +14,6 @@ struct n64_stagesetup { u32 ptr_padfiledata; }; - struct n64_coord { f32 x; f32 y; diff --git a/port/src/preprocess/filebg.c b/port/src/preprocess/filebg.c index 31f744ee8..55f173364 100644 --- a/port/src/preprocess/filebg.c +++ b/port/src/preprocess/filebg.c @@ -70,49 +70,13 @@ struct host_primaryheader { uintptr_t unused2; }; -struct n64_room { +struct n64_bgroom { u32 ptr_gfxdata; - u32 pos[3]; + struct coord pos; u8 br_light_min; u8 br_light_max; }; -struct host_room { - uintptr_t ptr_gfxdata; - u32 pos[3]; - u8 br_light_min; - u8 br_light_max; -}; - -struct portal { - u16 verticesoffset; - s16 roomnum1; - s16 roomnum2; - u8 flags; -}; - -struct generic_portalvertices { - u8 count; - u32 vertices[1][3]; -}; - -/* -struct light { - u16 roomnum; - u16 colour; - u8 brightness; - u8 sparkable : 1; - u8 healthy : 1; - u8 on : 1; - u8 sparking : 1; - u8 vulnerable : 1; - u8 brightnessmult; - s8 dirx; - s8 diry; - s8 dirz; - s16 bbox[4][3]; -};*/ - struct n64_roomblock { u8 type; u32 ptr_next; @@ -121,14 +85,6 @@ struct n64_roomblock { u32 ptr_colours; }; -struct host_roomblock { - u8 type; - uintptr_t ptr_next; - uintptr_t ptr_gdl; - uintptr_t ptr_vertices; - uintptr_t ptr_colours; -}; - struct n64_roomgfxdata { u32 ptr_vertices; u32 ptr_colours; @@ -141,18 +97,6 @@ struct n64_roomgfxdata { // roomblocks[] }; -struct host_roomgfxdata { - uintptr_t ptr_vertices; - uintptr_t ptr_colours; - uintptr_t ptr_opablocks; - uintptr_t ptr_xlublocks; - s16 lightsindex; - s16 numlights; - s16 numvertices; - s16 numcolours; - // roomblocks[] -}; - struct vtx { s16 coord[3]; u8 flag; @@ -161,38 +105,32 @@ struct vtx { u16 t; }; -int m_NumRooms; - -u32 m_AllocSizes[512]; - static void convertPrimaryRooms(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos) { - struct n64_room *n64_rooms = (struct n64_room *) &src[*srcpos]; - struct host_room *host_rooms = (struct host_room *) &dst[*dstpos]; + struct n64_bgroom *n64_rooms = (struct n64_bgroom *) &src[*srcpos]; + struct bgroom *host_rooms = (struct bgroom *) &dst[*dstpos]; - m_NumRooms = 0; + s32 numRooms = 0; for (int i = 1; n64_rooms[i].ptr_gfxdata != 0; i++) { - m_NumRooms++; + numRooms++; } - for (int i = 0; i < m_NumRooms + 1; i++) { - host_rooms[i].ptr_gfxdata = PD_BE32(n64_rooms[i].ptr_gfxdata); - host_rooms[i].pos[0] = PD_BE32(n64_rooms[i].pos[0]); - host_rooms[i].pos[1] = PD_BE32(n64_rooms[i].pos[1]); - host_rooms[i].pos[2] = PD_BE32(n64_rooms[i].pos[2]); + for (int i = 0; i < numRooms + 1; i++) { + host_rooms[i].unk00 = PD_BE32(n64_rooms[i].ptr_gfxdata); + host_rooms[i].pos = PD_SWAPPED_VAL(n64_rooms[i].pos); host_rooms[i].br_light_min = n64_rooms[i].br_light_min; host_rooms[i].br_light_max = n64_rooms[i].br_light_max; } - *srcpos += sizeof(*n64_rooms) * (m_NumRooms + 2); - *dstpos += sizeof(*host_rooms) * (m_NumRooms +2); + *srcpos += sizeof(*n64_rooms) * (numRooms + 2); + *dstpos += sizeof(*host_rooms) * (numRooms +2); } static void convertPrimaryPortals(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u32 *src_portalvtxs, u32 *dst_portalvtxs) { - struct portal *n64_portals = (struct portal *) &src[*srcpos]; - struct portal *host_portals = (struct portal *) &dst[*dstpos]; + struct bgportal *n64_portals = (struct bgportal *) &src[*srcpos]; + struct bgportal *host_portals = (struct bgportal *) &dst[*dstpos]; // Count portals int numportals = 0; @@ -216,18 +154,13 @@ static void convertPrimaryPortals(u8 *dst, u32 *dstpos, u8 *src, u32 *srcpos, u3 *dst_portalvtxs = *dstpos; while (1) { - struct generic_portalvertices *n64_pvertices = (struct generic_portalvertices*)&src[*srcpos]; - struct generic_portalvertices*host_pvertices = (struct generic_portalvertices*)&dst[*dstpos]; + struct portalvertices *n64_pvertices = (struct portalvertices *)&src[*srcpos]; + struct portalvertices *host_pvertices = (struct portalvertices *)&dst[*dstpos]; host_pvertices->count = n64_pvertices->count; for (int j = 0; j < host_pvertices->count; j++) { - //host_pvertices->vertices[j].x = PD_BE32(n64_pvertices->vertices[j].x); - //host_pvertices->vertices[j].y = PD_BE32(n64_pvertices->vertices[j].y); - //host_pvertices->vertices[j].z = PD_BE32(n64_pvertices->vertices[j].z); - host_pvertices->vertices[j][0] = PD_BE32(n64_pvertices->vertices[j][0]); - host_pvertices->vertices[j][1] = PD_BE32(n64_pvertices->vertices[j][1]); - host_pvertices->vertices[j][2] = PD_BE32(n64_pvertices->vertices[j][2]); + host_pvertices->vertices[j] = PD_SWAPPED_VAL(n64_pvertices->vertices[j]); } *srcpos += 4 + host_pvertices->count * 12; @@ -320,43 +253,43 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) int numgdls = 0; struct n64_roomgfxdata *src_header = (struct n64_roomgfxdata*)src; - struct host_roomgfxdata *dst_header = (struct host_roomgfxdata*)dst; + struct roomgfxdata *dst_header = (struct roomgfxdata*)dst; - dst_header->ptr_vertices = PD_BE32(src_header->ptr_vertices); - dst_header->ptr_colours = PD_BE32(src_header->ptr_colours); - dst_header->ptr_opablocks = PD_BE32(src_header->ptr_opablocks); - dst_header->ptr_xlublocks = PD_BE32(src_header->ptr_xlublocks); + dst_header->vertices = (void *)(uintptr_t)PD_BE32(src_header->ptr_vertices); + dst_header->colours = (void *)(uintptr_t)PD_BE32(src_header->ptr_colours); + dst_header->opablocks = (void *)(uintptr_t)PD_BE32(src_header->ptr_opablocks); + dst_header->xlublocks = (void *)(uintptr_t)PD_BE32(src_header->ptr_xlublocks); dst_header->lightsindex = PD_BE16(src_header->lightsindex); dst_header->numlights = PD_BE16(src_header->numlights); dst_header->numvertices = PD_BE16(src_header->numvertices); dst_header->numcolours = PD_BE16(src_header->numcolours); - intptr_t endpos = dst_header->ptr_vertices - src_ofs; + intptr_t endpos = (uintptr_t)dst_header->vertices - src_ofs; uintptr_t curpos_src = sizeof(struct n64_roomgfxdata); - uintptr_t curpos_dst = sizeof(struct host_roomgfxdata); + uintptr_t curpos_dst = sizeof(struct roomgfxdata); // roomblocks int ncoords = 0; // save the ptr to roomblocks here to iterate later to fix the pointers - struct host_roomblock *ptr_dst_roomblocks = (struct host_roomblock*)&dst[curpos_dst]; + struct roomblock *ptr_dst_roomblocks = (struct roomblock*)&dst[curpos_dst]; int numblocks = 0; while ((intptr_t)(curpos_src + sizeof(struct n64_roomblock)) <= endpos) { struct n64_roomblock *src_roomblock = (struct n64_roomblock*)&src[curpos_src]; - struct host_roomblock *dest_roomblock = (struct host_roomblock*)&dst[curpos_dst]; + struct roomblock *dest_roomblock = (struct roomblock*)&dst[curpos_dst]; dest_roomblock->type = src_roomblock->type; - dest_roomblock->ptr_next = PD_BE32(src_roomblock->ptr_next); - dest_roomblock->ptr_gdl = PD_BE32(src_roomblock->ptr_gdl); - dest_roomblock->ptr_vertices = PD_BE32(src_roomblock->ptr_vertices); - dest_roomblock->ptr_colours = PD_BE32(src_roomblock->ptr_colours); + dest_roomblock->next = (void *)(uintptr_t)PD_BE32(src_roomblock->ptr_next); + dest_roomblock->gdl = (void *)(uintptr_t)PD_BE32(src_roomblock->ptr_gdl); + dest_roomblock->vertices = (void *)(uintptr_t)PD_BE32(src_roomblock->ptr_vertices); + dest_roomblock->colours = (void *)(uintptr_t)PD_BE32(src_roomblock->ptr_colours); ptrAdd(curpos_src + src_ofs, curpos_dst + dst_roomoffset); if (src_roomblock->type == BLOCK_PARENT) { ncoords++; - uintptr_t vtx_ptr = dest_roomblock->ptr_vertices - src_ofs; + uintptr_t vtx_ptr = (uintptr_t)dest_roomblock->vertices - src_ofs; if (vtx_ptr < endpos) endpos = vtx_ptr; } else if (src_roomblock->ptr_gdl) { @@ -364,7 +297,7 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) } curpos_src += sizeof(struct n64_roomblock); - curpos_dst += sizeof(struct host_roomblock); + curpos_dst += sizeof(struct roomblock); numblocks++; } @@ -390,15 +323,15 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) curpos_dst = ALIGN8(curpos_dst); // vertices - uintptr_t ptr_src_vertices = curpos_src = ALIGN8(dst_header->ptr_vertices - src_ofs); + uintptr_t ptr_src_vertices = curpos_src = ALIGN8((uintptr_t)dst_header->vertices - src_ofs); uintptr_t ptr_dst_vertices = curpos_dst + dst_roomoffset; ptrAdd(curpos_src + src_ofs, curpos_dst + dst_roomoffset); - uintptr_t vtx_end = dst_header->ptr_colours - src_ofs; + uintptr_t vtx_end = (uintptr_t)dst_header->colours - src_ofs; - while (dst_header->ptr_colours && curpos_src < vtx_end) { - struct vtx *src_vtx = (struct vtx*)(src + curpos_src); + while (dst_header->colours && curpos_src < vtx_end) { + struct vtx *src_vtx = (struct vtx*)(src + curpos_src); struct vtx *dst_vtx = (struct vtx*)(dst + curpos_dst); dst_vtx->coord[0] = PD_BE16(src_vtx->coord[0]); @@ -421,8 +354,8 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) uintptr_t ptr_src_colors = 0; uintptr_t ptr_dst_colors = 0; - if (dst_header->ptr_colours) { - ptr_src_colors = curpos_src = ALIGN8(dst_header->ptr_colours - src_ofs); + if (dst_header->colours) { + ptr_src_colors = curpos_src = ALIGN8((uintptr_t)dst_header->colours - src_ofs); ptr_dst_colors = curpos_dst + dst_roomoffset; ptrAdd(curpos_src + src_ofs, curpos_dst + dst_roomoffset); @@ -437,7 +370,7 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) // gdls gbiSetVtx(src_header->ptr_vertices, ptr_src_vertices); - gbiSetSegment(0x0e, dst_header->ptr_vertices); + gbiSetSegment(0x0e, (uintptr_t)dst_header->vertices); uintptr_t gdlstart = curpos_dst; for (size_t i = 0; i < numgdls; i++) { @@ -447,29 +380,29 @@ static u32 convertRoomGfxData(u8 *dst, u8 *src, u32 infsize, u32 src_ofs) // relink ptrs: roomblocks for (size_t i = 0; i < numblocks; i++) { - struct host_roomblock *block = (struct host_roomblock*)&ptr_dst_roomblocks[i]; - - relinkPtr((uintptr_t*)&block->ptr_next); + struct roomblock *block = (struct roomblock*)&ptr_dst_roomblocks[i]; + + relinkPtr((uintptr_t*)&block->next); if (block->type == BLOCK_LEAF) { - relinkPtr((uintptr_t*)&block->ptr_gdl); - u32 offset_vtx = block->ptr_vertices - ptr_src_vertices - src_ofs; - u32 offset_col = block->ptr_colours - ptr_src_colors - src_ofs; + relinkPtr((uintptr_t*)&block->gdl); + u32 offset_vtx = (uintptr_t)block->vertices - ptr_src_vertices - src_ofs; + u32 offset_col = (uintptr_t)block->colours - ptr_src_colors - src_ofs; - block->ptr_vertices = ptr_dst_vertices + offset_vtx; - block->ptr_colours = ptr_dst_colors + offset_col; + block->vertices = (void *)(ptr_dst_vertices + offset_vtx); + block->colours = (void *)(ptr_dst_colors + offset_col); } else { - relinkPtr((uintptr_t*)&block->ptr_gdl); // child - relinkPtr((uintptr_t*)&block->ptr_vertices); // coord + relinkPtr((uintptr_t*)&block->gdl); // child + relinkPtr((uintptr_t*)&block->vertices); // coord } } // relink ptrs: header - relinkPtr((uintptr_t*)&dst_header->ptr_vertices); - relinkPtr((uintptr_t*)&dst_header->ptr_colours); - relinkPtr((uintptr_t*)&dst_header->ptr_opablocks); - relinkPtr((uintptr_t*)&dst_header->ptr_xlublocks); + relinkPtr((uintptr_t*)&dst_header->vertices); + relinkPtr((uintptr_t*)&dst_header->colours); + relinkPtr((uintptr_t*)&dst_header->opablocks); + relinkPtr((uintptr_t*)&dst_header->xlublocks); return curpos_dst; } diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index 46f8e8ea4..0d9ca077e 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -76,7 +76,7 @@ static const struct alignconfig alignConfigs[] = { static struct marker contentMarkers[1024]; static int numContentMarkers; -struct src_modeldef { +struct n64_modeldef { u32 ptr_rootnode; u32 ptr_skel; u32 ptr_parts; @@ -88,19 +88,7 @@ struct src_modeldef { u32 ptr_texconfigs; }; -struct dst_modeldef { - uintptr_t ptr_rootnode; - uintptr_t ptr_skel; - uintptr_t ptr_parts; - s16 numparts; - s16 nummatrices; - u32 scale; - u16 rwdatalen; - u16 numtexconfigs; - uintptr_t ptr_texconfigs; -}; - -struct src_modelnode { +struct n64_modelnode { u16 type; u32 ptr_rodata; u32 ptr_parent; @@ -109,30 +97,7 @@ struct src_modelnode { u32 ptr_child; }; -struct dst_modelnode { - u16 type; - uintptr_t ptr_rodata; - uintptr_t ptr_parent; - uintptr_t ptr_next; - uintptr_t ptr_prev; - uintptr_t ptr_child; -}; - -struct generic_rodata_chrinfo { - u16 animpart; - s16 mtxindex; - u32 unk04; - u16 rwdataindex; -}; - -struct generic_rodata_position { - u32 pos[3]; - u16 part; - s16 mtxindexes[3]; - u32 drawdist; -}; - -struct src_rodata_gundl { +struct n64_modelrodata_gundl { u32 ptr_opagdl; u32 ptr_xlugdl; u32 ptr_baseaddr; @@ -141,75 +106,34 @@ struct src_rodata_gundl { s16 unk12; }; -struct dst_rodata_gundl { - uintptr_t ptr_opagdl; - uintptr_t ptr_xlugdl; - uintptr_t ptr_baseaddr; - uintptr_t ptr_vertices; - s16 numvertices; - s16 unk12; -}; - -struct src_rodata_distance { - u32 near; - u32 far; +struct n64_modelrodata_distance { + f32 near; + f32 far; u32 ptr_target; u16 rwdataindex; }; -struct dst_rodata_distance { - u32 near; - u32 far; - uintptr_t ptr_target; - u16 rwdataindex; -}; - -struct src_rodata_reorder { - u32 unk00; - u32 unk04; - u32 unk08; - u32 unk0c[3]; +struct n64_modelrodata_reorder { + f32 unk00; + f32 unk04; + f32 unk08; + f32 unk0c[3]; u32 ptr_node_unk18; u32 ptr_node_unk1c; s16 side; u16 rwdataindex; }; -struct dst_rodata_reorder { - u32 unk00; - u32 unk04; - u32 unk08; - u32 unk0c[3]; - uintptr_t ptr_node_unk18; - uintptr_t ptr_node_unk1c; - s16 side; - u16 rwdataindex; -}; - -struct generic_rodata_bbox { - s32 hitpart; - u32 bbox[6]; -}; - -struct src_rodata_chrgunfire { - u32 pos[3]; - u32 dim[3]; +struct n64_modelrodata_chrgunfire { + struct coord pos; + struct coord dim; u32 ptr_texture; - u32 unk1c; + f32 unk1c; u16 rwdataindex; u32 ptr_baseaddr; }; -struct dst_rodata_chrgunfire { - u32 pos[3]; - u32 dim[3]; - uintptr_t ptr_texture; - u32 unk1c; - u16 rwdataindex; - uintptr_t ptr_baseaddr; -}; - -struct src_rodata_type11 { +struct n64_modelrodata_type11 { u32 unk00; u32 unk04; u32 unk08; @@ -220,52 +144,19 @@ struct src_rodata_type11 { u32 extra2; }; -struct dst_rodata_type11 { - u32 unk00; - u32 unk04; - u32 unk08; - u32 unk0c; - u32 unk10; - u32 unk14; - u32 extra1; - u32 extra2; -}; - -struct src_rodata_toggle { +struct n64_modelrodata_toggle { u32 ptr_target; u16 rwdataindex; }; -struct dst_rodata_toggle { - uintptr_t ptr_target; - u16 rwdataindex; -}; - -struct generic_rodata_positionheld { - u32 pos[3]; - s16 mtxindex; - u32 unk10; -}; - -struct src_rodata_stargunfire { +struct n64_modelrodata_stargunfire { u32 unk00; u32 ptr_vertices; u32 ptr_gdl; u32 ptr_baseaddr; }; -struct dst_rodata_stargunfire { - u32 unk00; - uintptr_t ptr_vertices; - uintptr_t ptr_gdl; - uintptr_t ptr_baseaddr; -}; - -struct generic_rodata_headspot { - u16 rwdataindex; -}; - -struct src_rodata_dl { +struct n64_modelrodata_dl { u32 ptr_opagdl; u32 ptr_xlugdl; u32 ptr_colours; @@ -276,23 +167,7 @@ struct src_rodata_dl { u16 numcolours; }; -struct dst_rodata_dl { - uintptr_t ptr_opagdl; - uintptr_t ptr_xlugdl; - uintptr_t ptr_colours; - uintptr_t ptr_vertices; // colours follow this array - s16 numvertices; - s16 mcount; - u16 rwdataindex; - u16 numcolours; -}; - -struct generic_rodata_type19 { - u32 numvertices; - u32 vertices[3]; -}; - -struct src_texconfig { +struct n64_textureconfig { u32 ptr; u8 width; u8 height; @@ -304,18 +179,6 @@ struct src_texconfig { u8 unk0b; }; -struct dst_texconfig { - uintptr_t ptr; - u8 width; - u8 height; - u8 level; - u8 format; - u8 depth; - u8 s; - u8 t; - u8 unk0b; -}; - static inline uintptr_t minPtr(uintptr_t a, uintptr_t b) { return (a && (a < b || !b)) ? a : b; } @@ -400,18 +263,18 @@ static void populateMarkers(u8 *src) switch (marker->type) { case CT_MODELDEF: - struct src_modeldef *src_modeldef = src_thing; + struct n64_modeldef *src_modeldef = src_thing; int num_texconfigs = PD_BE16(src_modeldef->numtexconfigs); u32 texconfigpos = PD_BE32(src_modeldef->ptr_texconfigs); setMarker(PD_BE32(src_modeldef->ptr_rootnode), CT_NODE, marker->src_offset); setMarker(PD_BE32(src_modeldef->ptr_parts), CT_PARTS, marker->src_offset); for (int i = 0; i < num_texconfigs; i++) { - setMarker(texconfigpos + sizeof(struct src_texconfig) * i, CT_TEXCONFIG, marker->src_offset); + setMarker(texconfigpos + sizeof(struct n64_textureconfig) * i, CT_TEXCONFIG, marker->src_offset); } break; case CT_NODE: - struct src_modelnode *src_node = src_thing; + struct n64_modelnode *src_node = src_thing; u32 node_type = PD_BE16(src_node->type) & 0xff; setMarker(PD_BE32(src_node->ptr_rodata), nodeTypeToContentType[node_type], marker->src_offset); setMarker(PD_BE32(src_node->ptr_parent), CT_NODE, marker->src_offset); @@ -420,13 +283,13 @@ static void populateMarkers(u8 *src) setMarker(PD_BE32(src_node->ptr_child), CT_NODE, marker->src_offset); break; case CT_TEXCONFIG: - struct src_texconfig *src_texconfig = src_thing; + struct n64_textureconfig *src_texconfig = src_thing; if ((PD_BE32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { setMarker(PD_BE32(src_texconfig->ptr), CT_TEXDATA, marker->src_offset); } break; case CT_PARTS: - struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + struct n64_modeldef *src_modeldef2 = (struct n64_modeldef *) src; u32 *src_parts = (u32 *) src_thing; int num_parts = PD_BE16(src_modeldef2->numparts); @@ -439,30 +302,30 @@ static void populateMarkers(u8 *src) case CT_RODATA_POSITION: break; case CT_RODATA_GUNDL: - struct src_rodata_gundl *src_gundl = src_thing; + struct n64_modelrodata_gundl *src_gundl = src_thing; setMarker(PD_BE32(src_gundl->ptr_opagdl), CT_GDL, marker->src_offset); setMarker(PD_BE32(src_gundl->ptr_xlugdl), CT_GDL, marker->src_offset); setMarker(PD_BE32(src_gundl->ptr_vertices), CT_VTXCOL, marker->src_offset); break; case CT_RODATA_DISTANCE: - struct src_rodata_distance *src_dist = src_thing; + struct n64_modelrodata_distance *src_dist = src_thing; setMarker(PD_BE32(src_dist->ptr_target), CT_NODE, marker->src_offset); break; case CT_RODATA_REORDER: - struct src_rodata_reorder *src_reorder = src_thing; + struct n64_modelrodata_reorder *src_reorder = src_thing; setMarker(PD_BE32(src_reorder->ptr_node_unk18), CT_NODE, marker->src_offset); setMarker(PD_BE32(src_reorder->ptr_node_unk1c), CT_NODE, marker->src_offset); break; case CT_RODATA_CHRGUNFIRE: - struct src_rodata_chrgunfire *src_chrgunfire = src_thing; + struct n64_modelrodata_chrgunfire *src_chrgunfire = src_thing; setMarker(PD_BE32(src_chrgunfire->ptr_texture), CT_TEXCONFIG, marker->src_offset); break; case CT_RODATA_TOGGLE: - struct src_rodata_toggle *src_toggle = src_thing; + struct n64_modelrodata_toggle *src_toggle = src_thing; setMarker(PD_BE32(src_toggle->ptr_target), CT_NODE, marker->src_offset); break; case CT_RODATA_STARGUNFIRE: - struct src_rodata_stargunfire *src_stargunfire = src_thing; + struct n64_modelrodata_stargunfire *src_stargunfire = src_thing; colstart = PD_BE32(src_stargunfire->unk00)*4*(sizeof(s16) * 6); u32 vtxstart = PD_BE32(src_stargunfire->ptr_vertices); u32 vtxend = vtxstart + colstart; @@ -475,7 +338,7 @@ static void populateMarkers(u8 *src) setMarker(PD_BE32(src_stargunfire->ptr_gdl), CT_GDL, marker->src_offset); break; case CT_RODATA_DL: - struct src_rodata_dl *src_dl = src_thing; + struct n64_modelrodata_dl *src_dl = src_thing; setMarker(PD_BE32(src_dl->ptr_opagdl), CT_GDL, marker->src_offset); setMarker(PD_BE32(src_dl->ptr_xlugdl), CT_GDL, marker->src_offset); setMarker(PD_BE32(src_dl->ptr_colours), CT_VTXCOL, marker->src_offset); @@ -534,9 +397,9 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) switch (marker->type) { case CT_MODELDEF: - struct src_modeldef *src_modeldef = src_thing; - struct dst_modeldef *dst_modeldef = dst_thing; - dst_modeldef->ptr_skel = PD_BE32(src_modeldef->ptr_skel); + struct n64_modeldef *src_modeldef = src_thing; + struct modeldef *dst_modeldef = dst_thing; + dst_modeldef->skel = (void *)(uintptr_t)PD_BE32(src_modeldef->ptr_skel); dst_modeldef->numparts = PD_BE16(src_modeldef->numparts); dst_modeldef->nummatrices = PD_BE16(src_modeldef->nummatrices); dst_modeldef->scale = PD_BE32(src_modeldef->scale); @@ -545,18 +408,18 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) dstpos += sizeof(*dst_modeldef); break; case CT_NODE: - struct src_modelnode *src_node = src_thing; - struct dst_modelnode *dst_node = dst_thing; + struct n64_modelnode *src_node = src_thing; + struct modelnode *dst_node = dst_thing; dst_node->type = PD_BE16(src_node->type); dstpos += sizeof(*dst_node); break; case CT_TEXCONFIG: - struct src_texconfig *src_texconfig = src_thing; - struct dst_texconfig *dst_texconfig = dst_thing; + struct n64_textureconfig *src_texconfig = src_thing; + struct textureconfig *dst_texconfig = dst_thing; while (src_len >= sizeof(*src_texconfig)) { if ((PD_BE32(src_texconfig->ptr) & 0xff000000) != 0x05000000) { - dst_texconfig->ptr = PD_BE32(src_texconfig->ptr); + dst_texconfig->textureptr = (void *)(uintptr_t)PD_BE32(src_texconfig->ptr); } dst_texconfig->width = src_texconfig->width; @@ -579,7 +442,7 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) dstpos += src_len; break; case CT_PARTS: - struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + struct n64_modeldef *src_modeldef2 = (struct n64_modeldef *) src; u32 *src_parts = (u32 *) src_thing; uintptr_t *dst_parts = (uintptr_t *) dst_thing; int num_parts = PD_BE16(src_modeldef2->numparts); @@ -605,27 +468,27 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) u32 dst_vtx; if (parent->type == CT_RODATA_GUNDL) { - struct src_rodata_gundl *src_rodata = (struct src_rodata_gundl *) &src[parent->src_offset]; - struct dst_rodata_gundl *dst_rodata = (struct dst_rodata_gundl *) &dst[parent->dst_offset]; + struct n64_modelrodata_gundl *src_rodata = (struct n64_modelrodata_gundl *) &src[parent->src_offset]; + struct modelrodata_gundl *dst_rodata = (struct modelrodata_gundl *) &dst[parent->dst_offset]; src_vtx = PD_BE32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = (dst_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = ((uintptr_t)dst_rodata->vertices) & 0x00ffffff; } else if (parent->type == CT_RODATA_STARGUNFIRE) { - struct src_rodata_stargunfire *src_rodata = (struct src_rodata_stargunfire *) &src[parent->src_offset]; - struct dst_rodata_stargunfire *dst_rodata = (struct dst_rodata_stargunfire *) &dst[parent->dst_offset]; + struct n64_modelrodata_stargunfire *src_rodata = (struct n64_modelrodata_stargunfire *) &src[parent->src_offset]; + struct modelrodata_stargunfire *dst_rodata = (struct modelrodata_stargunfire *) &dst[parent->dst_offset]; src_vtx = PD_BE32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = (dst_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = ((uintptr_t)dst_rodata->vertices) & 0x00ffffff; } else if (parent->type == CT_RODATA_DL) { - struct src_rodata_dl *src_rodata = (struct src_rodata_dl *) &src[parent->src_offset]; - struct dst_rodata_dl *dst_rodata = (struct dst_rodata_dl *) &dst[parent->dst_offset]; + struct n64_modelrodata_dl *src_rodata = (struct n64_modelrodata_dl *) &src[parent->src_offset]; + struct modelrodata_dl *dst_rodata = (struct modelrodata_dl *) &dst[parent->dst_offset]; src_vtx = PD_BE32(src_rodata->ptr_vertices) & 0x00ffffff; - dst_vtx = (dst_rodata->ptr_vertices) & 0x00ffffff; + dst_vtx = ((uintptr_t)dst_rodata->vertices) & 0x00ffffff; } dstpos = gbiConvertGdl(dst, dstpos, src, marker->src_offset, 0); break; case CT_RODATA_CHRINFO: - struct generic_rodata_chrinfo *src_chrinfo = src_thing; - struct generic_rodata_chrinfo *dst_chrinfo = dst_thing; + struct modelrodata_chrinfo *src_chrinfo = src_thing; + struct modelrodata_chrinfo *dst_chrinfo = dst_thing; dst_chrinfo->animpart = PD_BE16(src_chrinfo->animpart); dst_chrinfo->mtxindex = PD_BE16(src_chrinfo->mtxindex); dst_chrinfo->unk04 = PD_BE32(src_chrinfo->unk04); @@ -633,116 +496,108 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) dstpos += sizeof(*dst_chrinfo); break; case CT_RODATA_POSITION: - struct generic_rodata_position *src_position = src_thing; - struct generic_rodata_position *dst_position = dst_thing; - dst_position->pos[0] = PD_BE32(src_position->pos[0]); - dst_position->pos[1] = PD_BE32(src_position->pos[1]); - dst_position->pos[2] = PD_BE32(src_position->pos[2]); + struct modelrodata_position *src_position = src_thing; + struct modelrodata_position *dst_position = dst_thing; + dst_position->pos = PD_SWAPPED_VAL(src_position->pos); dst_position->part = PD_BE16(src_position->part); dst_position->mtxindexes[0] = PD_BE16(src_position->mtxindexes[0]); dst_position->mtxindexes[1] = PD_BE16(src_position->mtxindexes[1]); dst_position->mtxindexes[2] = PD_BE16(src_position->mtxindexes[2]); - dst_position->drawdist = PD_BE32(src_position->drawdist); + dst_position->drawdist = PD_SWAPPED_VAL(src_position->drawdist); dstpos += sizeof(*dst_position); break; case CT_RODATA_GUNDL: - struct src_rodata_gundl *src_gundl = src_thing; - struct dst_rodata_gundl *dst_gundl = dst_thing; - dst_gundl->ptr_vertices = 0; + struct n64_modelrodata_gundl *src_gundl = src_thing; + struct modelrodata_gundl *dst_gundl = dst_thing; + dst_gundl->vertices = NULL; dst_gundl->numvertices = PD_BE16(src_gundl->numvertices); dst_gundl->unk12 = PD_BE16(src_gundl->unk12); dstpos += sizeof(*dst_gundl); break; case CT_RODATA_DISTANCE: - struct src_rodata_distance *src_dist = src_thing; - struct dst_rodata_distance *dst_dist = dst_thing; - dst_dist->near = PD_BE32(src_dist->near); - dst_dist->far = PD_BE32(src_dist->far); + struct n64_modelrodata_distance *src_dist = src_thing; + struct modelrodata_distance *dst_dist = dst_thing; + dst_dist->near = PD_SWAPPED_VAL(src_dist->near); + dst_dist->far = PD_SWAPPED_VAL(src_dist->far); dst_dist->rwdataindex = PD_BE16(src_dist->rwdataindex); dstpos += sizeof(*dst_dist); break; case CT_RODATA_REORDER: - struct src_rodata_reorder *src_reorder = src_thing; - struct dst_rodata_reorder *dst_reorder = dst_thing; - dst_reorder->unk00 = PD_BE32(src_reorder->unk00); - dst_reorder->unk04 = PD_BE32(src_reorder->unk04); - dst_reorder->unk08 = PD_BE32(src_reorder->unk08); - dst_reorder->unk0c[0] = PD_BE32(src_reorder->unk0c[0]); - dst_reorder->unk0c[1] = PD_BE32(src_reorder->unk0c[1]); - dst_reorder->unk0c[2] = PD_BE32(src_reorder->unk0c[2]); + struct n64_modelrodata_reorder *src_reorder = src_thing; + struct modelrodata_reorder *dst_reorder = dst_thing; + dst_reorder->unk00 = PD_SWAPPED_VAL(src_reorder->unk00); + dst_reorder->unk04 = PD_SWAPPED_VAL(src_reorder->unk04); + dst_reorder->unk08 = PD_SWAPPED_VAL(src_reorder->unk08); + dst_reorder->unk0c[0] = PD_SWAPPED_VAL(src_reorder->unk0c[0]); + dst_reorder->unk0c[1] = PD_SWAPPED_VAL(src_reorder->unk0c[1]); + dst_reorder->unk0c[2] = PD_SWAPPED_VAL(src_reorder->unk0c[2]); dst_reorder->side = PD_BE16(src_reorder->side); dst_reorder->rwdataindex = PD_BE16(src_reorder->rwdataindex); dstpos += sizeof(*dst_reorder); break; case CT_RODATA_BBOX: - struct generic_rodata_bbox *src_bbox = src_thing; - struct generic_rodata_bbox *dst_bbox = dst_thing; + struct modelrodata_bbox *src_bbox = src_thing; + struct modelrodata_bbox *dst_bbox = dst_thing; dst_bbox->hitpart = PD_BE32(src_bbox->hitpart); - dst_bbox->bbox[0] = PD_BE32(src_bbox->bbox[0]); - dst_bbox->bbox[1] = PD_BE32(src_bbox->bbox[1]); - dst_bbox->bbox[2] = PD_BE32(src_bbox->bbox[2]); - dst_bbox->bbox[3] = PD_BE32(src_bbox->bbox[3]); - dst_bbox->bbox[4] = PD_BE32(src_bbox->bbox[4]); - dst_bbox->bbox[5] = PD_BE32(src_bbox->bbox[5]); + dst_bbox->xmin = PD_SWAPPED_VAL(src_bbox->xmin); + dst_bbox->xmax = PD_SWAPPED_VAL(src_bbox->xmax); + dst_bbox->ymin = PD_SWAPPED_VAL(src_bbox->ymin); + dst_bbox->ymax = PD_SWAPPED_VAL(src_bbox->ymax); + dst_bbox->zmin = PD_SWAPPED_VAL(src_bbox->zmin); + dst_bbox->zmax = PD_SWAPPED_VAL(src_bbox->zmax); dstpos += sizeof(*dst_bbox); break; case CT_RODATA_CHRGUNFIRE: - struct src_rodata_chrgunfire *src_chrgunfire = src_thing; - struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; - dst_chrgunfire->pos[0] = PD_BE32(src_chrgunfire->pos[0]); - dst_chrgunfire->pos[1] = PD_BE32(src_chrgunfire->pos[1]); - dst_chrgunfire->pos[2] = PD_BE32(src_chrgunfire->pos[2]); - dst_chrgunfire->dim[0] = PD_BE32(src_chrgunfire->dim[0]); - dst_chrgunfire->dim[1] = PD_BE32(src_chrgunfire->dim[1]); - dst_chrgunfire->dim[2] = PD_BE32(src_chrgunfire->dim[2]); - dst_chrgunfire->unk1c = PD_BE32(src_chrgunfire->unk1c); + struct n64_modelrodata_chrgunfire *src_chrgunfire = src_thing; + struct modelrodata_chrgunfire *dst_chrgunfire = dst_thing; + dst_chrgunfire->pos = PD_SWAPPED_VAL(src_chrgunfire->pos); + dst_chrgunfire->dim = PD_SWAPPED_VAL(src_chrgunfire->dim); + dst_chrgunfire->unk1c = PD_SWAPPED_VAL(src_chrgunfire->unk1c); dst_chrgunfire->rwdataindex = PD_BE16(src_chrgunfire->rwdataindex); - dst_chrgunfire->ptr_baseaddr = 0; + dst_chrgunfire->baseaddr = NULL; dstpos += sizeof(*dst_chrgunfire); break; case CT_RODATA_11: - struct src_rodata_type11 *src_type11 = src_thing; - struct dst_rodata_type11 *dst_type11 = dst_thing; + struct n64_modelrodata_type11 *src_type11 = src_thing; + struct modelrodata_type11 *dst_type11 = dst_thing; dst_type11->unk00 = PD_BE32(src_type11->unk00); dst_type11->unk04 = PD_BE32(src_type11->unk04); dst_type11->unk08 = PD_BE32(src_type11->unk08); dst_type11->unk0c = PD_BE32(src_type11->unk0c); dst_type11->unk10 = PD_BE32(src_type11->unk10); - dst_type11->extra1 = PD_BE32(src_type11->extra1); - dst_type11->extra2 = PD_BE32(src_type11->extra2); + dst_type11->unk14 = (void *)(uintptr_t)PD_BE32(src_type11->extra1); + dst_type11->unk18 = PD_BE32(src_type11->extra2); dstpos += sizeof(*dst_type11); break; case CT_RODATA_TOGGLE: - struct src_rodata_toggle *src_toggle = src_thing; - struct dst_rodata_toggle *dst_toggle = dst_thing; + struct n64_modelrodata_toggle *src_toggle = src_thing; + struct modelrodata_toggle *dst_toggle = dst_thing; dst_toggle->rwdataindex = PD_BE16(src_toggle->rwdataindex); dstpos += sizeof(*dst_toggle); break; case CT_RODATA_POSITIONHELD: - struct generic_rodata_positionheld *src_posheld = src_thing; - struct generic_rodata_positionheld *dst_posheld = dst_thing; - dst_posheld->pos[0] = PD_BE32(src_posheld->pos[0]); - dst_posheld->pos[1] = PD_BE32(src_posheld->pos[1]); - dst_posheld->pos[2] = PD_BE32(src_posheld->pos[2]); + struct modelrodata_positionheld *src_posheld = src_thing; + struct modelrodata_positionheld *dst_posheld = dst_thing; + dst_posheld->pos = PD_SWAPPED_VAL(src_posheld->pos); dst_posheld->mtxindex = PD_BE16(src_posheld->mtxindex); dst_posheld->unk10 = PD_BE32(src_posheld->unk10); dstpos += sizeof(*dst_posheld); break; case CT_RODATA_STARGUNFIRE: - struct src_rodata_stargunfire *src_stargunfire = src_thing; - struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; + struct n64_modelrodata_stargunfire *src_stargunfire = src_thing; + struct modelrodata_stargunfire *dst_stargunfire = dst_thing; dst_stargunfire->unk00 = PD_BE32(src_stargunfire->unk00); dstpos += sizeof(*dst_stargunfire); break; case CT_RODATA_HEADSPOT: - struct generic_rodata_headspot *src_headspot = src_thing; - struct generic_rodata_headspot *dst_headspot = dst_thing; + struct modelrodata_headspot *src_headspot = src_thing; + struct modelrodata_headspot *dst_headspot = dst_thing; dst_headspot->rwdataindex = PD_BE16(src_headspot->rwdataindex); dstpos += sizeof(*dst_headspot); break; case CT_RODATA_DL: - struct src_rodata_dl *src_dl = src_thing; - struct dst_rodata_dl *dst_dl = dst_thing; + struct n64_modelrodata_dl *src_dl = src_thing; + struct modelrodata_dl *dst_dl = dst_thing; dst_dl->numvertices = PD_BE16(src_dl->numvertices); dst_dl->mcount = PD_BE16(src_dl->mcount); dst_dl->rwdataindex = PD_BE16(src_dl->rwdataindex); @@ -750,8 +605,8 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) dstpos += sizeof(*dst_dl); break; case CT_RODATA_19: - struct generic_rodata_type19 *src_type19 = src_thing; - struct generic_rodata_type19 *dst_type19 = dst_thing; + struct modelrodata_type19 *src_type19 = src_thing; + struct modelrodata_type19 *dst_type19 = dst_thing; u32 *src_vertices = src_thing + sizeof(u32); u32 *dst_vertices = dst_thing + sizeof(u32); int num_vertices = PD_BE32(src_type19->numvertices); @@ -799,33 +654,33 @@ static u8 *relinkPointers(u8 *dst, u8 *src) switch (marker->type) { case CT_MODELDEF: - struct src_modeldef *src_modeldef = src_thing; - struct dst_modeldef *dst_modeldef = dst_thing; - dst_modeldef->ptr_rootnode = (resolvePointer(PD_BE32(src_modeldef->ptr_rootnode))); - dst_modeldef->ptr_parts = (resolvePointer(PD_BE32(src_modeldef->ptr_parts))); - dst_modeldef->ptr_texconfigs = (resolvePointer(PD_BE32(src_modeldef->ptr_texconfigs))); + struct n64_modeldef *src_modeldef = src_thing; + struct modeldef *dst_modeldef = dst_thing; + dst_modeldef->rootnode = (void *)(uintptr_t)resolvePointer(PD_BE32(src_modeldef->ptr_rootnode)); + dst_modeldef->parts = (void *)(uintptr_t)resolvePointer(PD_BE32(src_modeldef->ptr_parts)); + dst_modeldef->texconfigs = (void *)(uintptr_t)resolvePointer(PD_BE32(src_modeldef->ptr_texconfigs)); break; case CT_NODE: - struct src_modelnode *src_node = src_thing; - struct dst_modelnode *dst_node = dst_thing; - dst_node->ptr_rodata = (resolvePointer(PD_BE32(src_node->ptr_rodata))); - dst_node->ptr_parent = (resolvePointer(PD_BE32(src_node->ptr_parent))); - dst_node->ptr_next = (resolvePointer(PD_BE32(src_node->ptr_next))); - dst_node->ptr_prev = (resolvePointer(PD_BE32(src_node->ptr_prev))); - dst_node->ptr_child = (resolvePointer(PD_BE32(src_node->ptr_child))); + struct n64_modelnode *src_node = src_thing; + struct modelnode *dst_node = dst_thing; + dst_node->rodata = (void *)(uintptr_t)resolvePointer(PD_BE32(src_node->ptr_rodata)); + dst_node->parent = (void *)(uintptr_t)resolvePointer(PD_BE32(src_node->ptr_parent)); + dst_node->next = (void *)(uintptr_t)resolvePointer(PD_BE32(src_node->ptr_next)); + dst_node->prev = (void *)(uintptr_t)resolvePointer(PD_BE32(src_node->ptr_prev)); + dst_node->child = (void *)(uintptr_t)resolvePointer(PD_BE32(src_node->ptr_child)); - lowestptr = dst_node->ptr_rodata; + lowestptr = (uintptr_t)dst_node->rodata; break; case CT_TEXCONFIG: - struct src_texconfig *src_texconfig = src_thing; - struct dst_texconfig *dst_texconfig = dst_thing; + struct n64_textureconfig *src_texconfig = src_thing; + struct textureconfig *dst_texconfig = dst_thing; if ((PD_BE32(src_texconfig->ptr) & 0xff000000) == 0x05000000) { - dst_texconfig->ptr = (resolvePointer(PD_BE32(src_texconfig->ptr))); - gbiAddTexAddr(PD_BE32(src_texconfig->ptr), dst_texconfig->ptr); + dst_texconfig->textureptr = (void *)(uintptr_t)resolvePointer(PD_BE32(src_texconfig->ptr)); + gbiAddTexAddr(PD_BE32(src_texconfig->ptr), (uintptr_t)dst_texconfig->textureptr); } break; case CT_PARTS: - struct src_modeldef *src_modeldef2 = (struct src_modeldef *) src; + struct n64_modeldef *src_modeldef2 = (struct n64_modeldef *) src; u32 *src_parts = (u32 *) src_thing; uintptr_t *dst_parts = (uintptr_t *) dst_thing; int num_parts = PD_BE16(src_modeldef2->numparts); @@ -839,84 +694,84 @@ static u8 *relinkPointers(u8 *dst, u8 *src) case CT_RODATA_POSITION: break; case CT_RODATA_GUNDL: - struct src_rodata_gundl *src_gundl = src_thing; - struct dst_rodata_gundl *dst_gundl = dst_thing; - dst_gundl->ptr_opagdl = (resolvePointer(PD_BE32(src_gundl->ptr_opagdl))); - dst_gundl->ptr_xlugdl = (resolvePointer(PD_BE32(src_gundl->ptr_xlugdl))); - dst_gundl->ptr_vertices = (resolvePointer(PD_BE32(src_gundl->ptr_vertices))); + struct n64_modelrodata_gundl *src_gundl = src_thing; + struct modelrodata_gundl *dst_gundl = dst_thing; + dst_gundl->opagdl = (void *)(uintptr_t)resolvePointer(PD_BE32(src_gundl->ptr_opagdl)); + dst_gundl->xlugdl = (void *)(uintptr_t)resolvePointer(PD_BE32(src_gundl->ptr_xlugdl)); + dst_gundl->vertices = (void *)(uintptr_t)resolvePointer(PD_BE32(src_gundl->ptr_vertices)); - gbiConvertVtx(dst, dst_gundl->ptr_vertices & 0x00ffffff, dst_gundl->numvertices); + gbiConvertVtx(dst, ((uintptr_t)dst_gundl->vertices) & 0x00ffffff, dst_gundl->numvertices); - gbiSetVtx(PD_BE32(src_gundl->ptr_vertices), dst_gundl->ptr_vertices); - gbiSetSegment(0x04, dst_gundl->ptr_vertices); + gbiSetVtx(PD_BE32(src_gundl->ptr_vertices), (uintptr_t)dst_gundl->vertices); + gbiSetSegment(0x04, (uintptr_t)dst_gundl->vertices); - gbiGdlRewriteAddrs(dst, dst_gundl->ptr_opagdl); - gbiGdlRewriteAddrs(dst, dst_gundl->ptr_xlugdl); + gbiGdlRewriteAddrs(dst, (uintptr_t)dst_gundl->opagdl); + gbiGdlRewriteAddrs(dst, (uintptr_t)dst_gundl->xlugdl); - if (dst_gundl->ptr_opagdl) dst_gundl->ptr_opagdl |= 1; - if (dst_gundl->ptr_xlugdl) dst_gundl->ptr_xlugdl |= 1; + if (dst_gundl->opagdl) dst_gundl->opagdl = SEGADDR(dst_gundl->opagdl); + if (dst_gundl->xlugdl) dst_gundl->xlugdl = SEGADDR(dst_gundl->xlugdl); - lowestptr = minPtr3(dst_gundl->ptr_opagdl, dst_gundl->ptr_xlugdl, dst_gundl->ptr_vertices); + lowestptr = minPtr3((uintptr_t)dst_gundl->opagdl, (uintptr_t)dst_gundl->xlugdl, (uintptr_t)dst_gundl->vertices); break; case CT_RODATA_DISTANCE: - struct src_rodata_distance *src_dist = src_thing; - struct dst_rodata_distance *dst_dist = dst_thing; - dst_dist->ptr_target = (resolvePointer(PD_BE32(src_dist->ptr_target))); + struct n64_modelrodata_distance *src_dist = src_thing; + struct modelrodata_distance *dst_dist = dst_thing; + dst_dist->target = (void *)(uintptr_t)resolvePointer(PD_BE32(src_dist->ptr_target)); break; case CT_RODATA_REORDER: - struct src_rodata_reorder *src_reorder = src_thing; - struct dst_rodata_reorder *dst_reorder = dst_thing; - dst_reorder->ptr_node_unk18 = (resolvePointer(PD_BE32(src_reorder->ptr_node_unk18))); - dst_reorder->ptr_node_unk1c = (resolvePointer(PD_BE32(src_reorder->ptr_node_unk1c))); + struct n64_modelrodata_reorder *src_reorder = src_thing; + struct modelrodata_reorder *dst_reorder = dst_thing; + dst_reorder->unk18 = (void *)(uintptr_t)resolvePointer(PD_BE32(src_reorder->ptr_node_unk18)); + dst_reorder->unk1c = (void *)(uintptr_t)resolvePointer(PD_BE32(src_reorder->ptr_node_unk1c)); break; case CT_RODATA_CHRGUNFIRE: - struct src_rodata_chrgunfire *src_chrgunfire = src_thing; - struct dst_rodata_chrgunfire *dst_chrgunfire = dst_thing; - dst_chrgunfire->ptr_texture = (resolvePointer(PD_BE32(src_chrgunfire->ptr_texture))); - if ((PD_BE32(dst_chrgunfire->ptr_texture) & 0xff000000) == 0x05000000) { - gbiAddTexAddr(PD_BE32(dst_chrgunfire->ptr_texture), dst_chrgunfire->ptr_texture); + struct n64_modelrodata_chrgunfire *src_chrgunfire = src_thing; + struct modelrodata_chrgunfire *dst_chrgunfire = dst_thing; + dst_chrgunfire->texture = (void *)(uintptr_t)resolvePointer(PD_BE32(src_chrgunfire->ptr_texture)); + if ((PD_BE32((u32)(uintptr_t)dst_chrgunfire->texture) & 0xff000000) == 0x05000000) { + gbiAddTexAddr(PD_BE32((u32)(uintptr_t)dst_chrgunfire->texture), (uintptr_t)dst_chrgunfire->texture); } break; case CT_RODATA_TOGGLE: - struct src_rodata_toggle *src_toggle = src_thing; - struct dst_rodata_toggle *dst_toggle = dst_thing; - dst_toggle->ptr_target = (resolvePointer(PD_BE32(src_toggle->ptr_target))); + struct n64_modelrodata_toggle *src_toggle = src_thing; + struct modelrodata_toggle *dst_toggle = dst_thing; + dst_toggle->target = (void *)(uintptr_t)resolvePointer(PD_BE32(src_toggle->ptr_target)); break; case CT_RODATA_STARGUNFIRE: - struct src_rodata_stargunfire *src_stargunfire = src_thing; - struct dst_rodata_stargunfire *dst_stargunfire = dst_thing; - dst_stargunfire->ptr_vertices = (resolvePointer(PD_BE32(src_stargunfire->ptr_vertices))); - dst_stargunfire->ptr_gdl = (resolvePointer(PD_BE32(src_stargunfire->ptr_gdl))); + struct n64_modelrodata_stargunfire *src_stargunfire = src_thing; + struct modelrodata_stargunfire *dst_stargunfire = dst_thing; + dst_stargunfire->vertices = (void *)(uintptr_t)resolvePointer(PD_BE32(src_stargunfire->ptr_vertices)); + dst_stargunfire->gdl = (void *)(uintptr_t)resolvePointer(PD_BE32(src_stargunfire->ptr_gdl)); - gbiConvertVtx(dst, dst_stargunfire->ptr_vertices & 0x00ffffff, dst_stargunfire->unk00*4); + gbiConvertVtx(dst, ((uintptr_t)dst_stargunfire->vertices) & 0x00ffffff, dst_stargunfire->unk00*4); - gbiSetVtx(PD_BE32(src_stargunfire->ptr_vertices), dst_stargunfire->ptr_vertices); - gbiSetSegment(0x04, dst_stargunfire->ptr_vertices); - gbiGdlRewriteAddrs(dst, dst_stargunfire->ptr_gdl); - if (dst_stargunfire->ptr_gdl) dst_stargunfire->ptr_gdl |= 1; + gbiSetVtx(PD_BE32(src_stargunfire->ptr_vertices), (uintptr_t)dst_stargunfire->vertices); + gbiSetSegment(0x04, (uintptr_t)dst_stargunfire->vertices); + gbiGdlRewriteAddrs(dst, (uintptr_t)dst_stargunfire->gdl); + if (dst_stargunfire->gdl) dst_stargunfire->gdl = SEGADDR(dst_stargunfire->gdl); - lowestptr = minPtr(dst_stargunfire->ptr_gdl, dst_stargunfire->ptr_vertices); + lowestptr = minPtr((uintptr_t)dst_stargunfire->gdl, (uintptr_t)dst_stargunfire->vertices); break; case CT_RODATA_DL: - struct src_rodata_dl *src_dl = src_thing; - struct dst_rodata_dl *dst_dl = dst_thing; - dst_dl->ptr_opagdl = (resolvePointer(PD_BE32(src_dl->ptr_opagdl))); - dst_dl->ptr_xlugdl = (resolvePointer(PD_BE32(src_dl->ptr_xlugdl))); - dst_dl->ptr_colours = (resolvePointer(PD_BE32(src_dl->ptr_colours))); - dst_dl->ptr_vertices = (resolvePointer(PD_BE32(src_dl->ptr_vertices))); + struct n64_modelrodata_dl *src_dl = src_thing; + struct modelrodata_dl *dst_dl = dst_thing; + dst_dl->opagdl = (void *)(uintptr_t)resolvePointer(PD_BE32(src_dl->ptr_opagdl)); + dst_dl->xlugdl = (void *)(uintptr_t)resolvePointer(PD_BE32(src_dl->ptr_xlugdl)); + dst_dl->colours = (void *)(uintptr_t)resolvePointer(PD_BE32(src_dl->ptr_colours)); + dst_dl->vertices = (void *)(uintptr_t)resolvePointer(PD_BE32(src_dl->ptr_vertices)); - gbiConvertVtx(dst, dst_dl->ptr_vertices & 0x00ffffff, dst_dl->numvertices); + gbiConvertVtx(dst, ((uintptr_t)dst_dl->vertices) & 0x00ffffff, dst_dl->numvertices); - gbiSetVtx(PD_BE32(src_dl->ptr_vertices), dst_dl->ptr_vertices); - gbiSetSegment(0x04, dst_dl->ptr_vertices); - gbiGdlRewriteAddrs(dst, dst_dl->ptr_opagdl); - gbiGdlRewriteAddrs(dst, dst_dl->ptr_xlugdl); + gbiSetVtx(PD_BE32(src_dl->ptr_vertices), (uintptr_t)dst_dl->vertices); + gbiSetSegment(0x04, (uintptr_t)dst_dl->vertices); + gbiGdlRewriteAddrs(dst, (uintptr_t)dst_dl->opagdl); + gbiGdlRewriteAddrs(dst, (uintptr_t)dst_dl->xlugdl); - if (dst_dl->ptr_opagdl) dst_dl->ptr_opagdl |= 1; - if (dst_dl->ptr_xlugdl) dst_dl->ptr_xlugdl |= 1; + if (dst_dl->opagdl) dst_dl->opagdl = SEGADDR(dst_dl->opagdl); + if (dst_dl->xlugdl) dst_dl->xlugdl = SEGADDR(dst_dl->xlugdl); - lowestptr = minPtr3(dst_dl->ptr_opagdl, dst_dl->ptr_xlugdl, dst_dl->ptr_colours); - lowestptr = minPtr(lowestptr, dst_dl->ptr_vertices); + lowestptr = minPtr3((uintptr_t)dst_dl->opagdl, (uintptr_t)dst_dl->xlugdl, (uintptr_t)dst_dl->colours); + lowestptr = minPtr(lowestptr, (uintptr_t)dst_dl->vertices); break; case CT_TEXDATA: case CT_VTXCOL: diff --git a/port/src/preprocess/filepads.c b/port/src/preprocess/filepads.c index 38ea015ed..1ba7e59d2 100644 --- a/port/src/preprocess/filepads.c +++ b/port/src/preprocess/filepads.c @@ -35,33 +35,13 @@ struct n64_waypoint { s32 step; }; -struct host_waypoint { - s32 padnum; - uintptr_t ptr_neighbours; - s32 groupnum; - s32 step; -}; - struct n64_waygroup { u32 ptr_neighbours; u32 ptr_waypoints; s32 step; }; -struct host_waygroup { - uintptr_t ptr_neighbours; - uintptr_t ptr_waypoints; - s32 step; -}; - -struct generic_coverdefinition { - u32 pos[3]; - u32 dir[3]; - u16 flags; - u16 unk1a; -}; - -static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) +static u32 convertPads(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int num_pads) { u16 *src_offsets = (u16 *) &src[srcpos]; u16 *dst_offsets = (u16 *) &dst[dstpos]; @@ -152,22 +132,22 @@ static int convertPads(u8 *dst, int dstpos, u8 *src, int srcpos, int num_pads) return dstpos; } -static int convertWayPoints(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertWayPoints(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { struct n64_waypoint *n64_waypoints = (struct n64_waypoint *) &src[srcpos]; - struct host_waypoint *host_waypoints = (struct host_waypoint *) &dst[dstpos]; + struct waypoint *host_waypoints = (struct waypoint *) &dst[dstpos]; int num_waypoints; for (num_waypoints = 0; n64_waypoints[num_waypoints].padnum != -1; num_waypoints++); - dstpos += (num_waypoints + 1) * sizeof(struct host_waypoint); + dstpos += (num_waypoints + 1) * sizeof(struct waypoint); u32 *host_neighbours = (u32 *) &dst[dstpos]; int n = 0; for (int i = 0; i < num_waypoints; i++) { host_waypoints[i].padnum = PD_BE32(n64_waypoints[i].padnum); - host_waypoints[i].ptr_neighbours = (dstpos); + host_waypoints[i].neighbours = (void *)(uintptr_t)dstpos; host_waypoints[i].groupnum = PD_BE32(n64_waypoints[i].groupnum); host_waypoints[i].step = 0; @@ -184,29 +164,29 @@ static int convertWayPoints(u8 *dst, int dstpos, u8 *src, int srcpos) // Terminator host_waypoints[num_waypoints].padnum = 0xffffffff; - host_waypoints[num_waypoints].ptr_neighbours = 0; + host_waypoints[num_waypoints].neighbours = NULL; host_waypoints[num_waypoints].groupnum = 0; host_waypoints[num_waypoints].step = 0; return dstpos; } -static int convertWayGroups(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertWayGroups(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { struct n64_waygroup *n64_waygroups = (struct n64_waygroup *) &src[srcpos]; - struct host_waygroup *host_waygroups = (struct host_waygroup *) &dst[dstpos]; + struct waygroup *host_waygroups = (struct waygroup *) &dst[dstpos]; int num_waygroups; for (num_waygroups = 0; n64_waygroups[num_waygroups].ptr_neighbours != 0; num_waygroups++); - dstpos += (num_waygroups + 1) * sizeof(struct host_waygroup); + dstpos += (num_waygroups + 1) * sizeof(struct waygroup); // Waygroups and child waypoints u32 *host_waypoints = (u32 *) &dst[dstpos]; int n = 0; for (int i = 0; i < num_waygroups; i++) { - host_waygroups[i].ptr_waypoints = (dstpos); + host_waygroups[i].waypoints = (void *)(uintptr_t)dstpos; host_waygroups[i].step = 0; u32 *n64_waypoints = (u32 *) &src[PD_BE32(n64_waygroups[i].ptr_waypoints)]; @@ -221,8 +201,8 @@ static int convertWayGroups(u8 *dst, int dstpos, u8 *src, int srcpos) } // Terminator - host_waygroups[num_waygroups].ptr_neighbours = 0; - host_waygroups[num_waygroups].ptr_waypoints = 0; + host_waygroups[num_waygroups].neighbours = NULL; + host_waygroups[num_waygroups].waypoints = NULL; host_waygroups[num_waygroups].step = 0; // Waygroup neighbours @@ -230,7 +210,7 @@ static int convertWayGroups(u8 *dst, int dstpos, u8 *src, int srcpos) n = 0; for (int i = 0; i < num_waygroups; i++) { - host_waygroups[i].ptr_neighbours = (dstpos); + host_waygroups[i].neighbours = (void *)(uintptr_t)dstpos; u32 *n64_neighbours = (u32 *) &src[PD_BE32(n64_waygroups[i].ptr_neighbours)]; @@ -246,30 +226,26 @@ static int convertWayGroups(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertCover(u8 *dst, int dstpos, u8 *src, int srcpos, int num_covers) +static u32 convertCover(u8 *dst, u32 dstpos, u8 *src, u32 srcpos, int num_covers) { - struct generic_coverdefinition *n64_covers = (struct generic_coverdefinition *) &src[srcpos]; - struct generic_coverdefinition *host_covers = (struct generic_coverdefinition *) &dst[dstpos]; + struct coverdefinition *n64_covers = (struct coverdefinition *) &src[srcpos]; + struct coverdefinition *host_covers = (struct coverdefinition *) &dst[dstpos]; for (int i = 0; i < num_covers; i++) { - host_covers[i].pos[0] = PD_BE32(n64_covers[i].pos[0]); - host_covers[i].pos[1] = PD_BE32(n64_covers[i].pos[1]); - host_covers[i].pos[2] = PD_BE32(n64_covers[i].pos[2]); - host_covers[i].dir[0] = PD_BE32(n64_covers[i].dir[0]); - host_covers[i].dir[1] = PD_BE32(n64_covers[i].dir[1]); - host_covers[i].dir[2] = PD_BE32(n64_covers[i].dir[2]); + host_covers[i].pos = PD_SWAPPED_VAL(n64_covers[i].pos); + host_covers[i].look = PD_SWAPPED_VAL(n64_covers[i].look); host_covers[i].flags = PD_BE16(n64_covers[i].flags); host_covers[i].unk1a = PD_BE16(n64_covers[i].unk1a); } - dstpos += num_covers * sizeof(struct generic_coverdefinition); + dstpos += num_covers * sizeof(struct coverdefinition); return dstpos; } -static int convertPadsFile(u8 *dst, u8 *src) +static u32 convertPadsFile(u8 *dst, u8 *src) { - int dstpos = 0; + u32 dstpos = 0; struct n64_header *n64_header = (struct n64_header *) src; struct host_header *host_header = (struct host_header *) dst; diff --git a/port/src/preprocess/filesetup.c b/port/src/preprocess/filesetup.c index 30b5d4da6..5e5ab9cc9 100644 --- a/port/src/preprocess/filesetup.c +++ b/port/src/preprocess/filesetup.c @@ -7,6 +7,8 @@ #include "preprocess/common.h" #include "preprocess/setup.h" +extern u32 chraiGetAilistLength(u8 *list); + static inline void convF32(f32 *dst, f32 src) { *(u32*)dst = PD_BE32(*(u32*)&src); } static inline void convU32(u32 *dst, u32 src) { *dst = PD_BE32(src); } static inline void convS32(s32 *dst, s32 src) { *dst = PD_BE32(src); } @@ -36,7 +38,7 @@ static inline void convUnk(u32 x) { assert(0 && "unknown type"); } #define PD_CONV_PTR(dst, src, type) dst = (type)(uintptr_t)PD_BE32(src) -static u32 obj_size(struct n64_defaultobj *obj) +static inline u32 objSizeN64(struct n64_defaultobj *obj) { switch (obj->type) { case OBJTYPE_CHR: return sizeof(struct n64_packedchr) / sizeof(u32); @@ -100,8 +102,7 @@ static u32 obj_size(struct n64_defaultobj *obj) return 1; } - -void conv_tvscreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) +static void convTvScreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) { PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist, u32*); PD_CONV_VAL(dstobj->offset, srcobj->offset); @@ -144,7 +145,7 @@ void conv_tvscreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) PD_CONV_VAL(dstobj->colinc, srcobj->colinc); } -void convertDefaultObjHdr(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) +static void convertDefaultObjHdr(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) { PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); @@ -164,7 +165,7 @@ void convertDefaultObjHdr(struct defaultobj* dstobj, struct n64_defaultobj* srco dst_unk00_2[1] = src_unk00_2[1]; } -void convertDefaultObj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) +static void convertDefaultObj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) { PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); PD_CONV_VAL(dstobj->hidden2, srcobj->hidden2); @@ -187,7 +188,7 @@ void convertDefaultObj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) PD_CONV_VAL(dstobj->geocount, srcobj->geocount); } -u32 convertProps(u8* dst, u8* src) +static u32 convertProps(u8* dst, u8* src) { u8* start = dst; struct n64_defaultobj* cmd = (struct n64_defaultobj*)src; @@ -373,7 +374,7 @@ u32 convertProps(u8* dst, u8* src) struct singlemonitorobj* dstobj = (struct singlemonitorobj*)dst; convertDefaultObj(&dstobj->base, cmd); - conv_tvscreen(&dstobj->screen, &srcobj->screen); + convTvScreen(&dstobj->screen, &srcobj->screen); PD_CONV_VAL(dstobj->owneroffset, srcobj->owneroffset); PD_CONV_VAL(dstobj->ownerpart, srcobj->ownerpart); @@ -390,7 +391,7 @@ u32 convertProps(u8* dst, u8* src) convertDefaultObj(&dstobj->base, cmd); for (size_t i = 0; i < 4; i++) - conv_tvscreen(&dstobj->screens[i], &srcobj->screens[i]); + convTvScreen(&dstobj->screens[i], &srcobj->screens[i]); PD_CONV_ARRAY(dstobj->imagenums, srcobj->imagenums); dst += sizeof(struct multimonitorobj); @@ -990,7 +991,7 @@ u32 convertProps(u8* dst, u8* src) } } - cmd = (struct n64_defaultobj*)((u32*)cmd + obj_size(cmd)); + cmd = (struct n64_defaultobj*)((u32*)cmd + objSizeN64(cmd)); type = cmd->type; } @@ -1099,8 +1100,6 @@ static u32 convertAiLists(u8* dst, u8* src) return (u32)((u8 *)dstailist - dst + sizeof(uintptr_t)); } -extern u32 chraiGetAilistLength(u8 *list); - static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) { ptrReset(); @@ -1137,7 +1136,7 @@ static u32 convertLists(u8 *dst, u8 *src, u32 dstpos, u32 src_ofs) return dstpos; } -static int convertSetup(u8 *dst, u8 *src, u32 srclen) +static u32 convertSetup(u8 *dst, u8 *src, u32 srclen) { struct n64_stagesetup *src_header = (struct n64_stagesetup*)src; struct stagesetup *dst_header = (struct stagesetup*)dst; diff --git a/port/src/preprocess/filetiles.c b/port/src/preprocess/filetiles.c index d83a7bd55..e1284b995 100644 --- a/port/src/preprocess/filetiles.c +++ b/port/src/preprocess/filetiles.c @@ -18,7 +18,7 @@ struct tile { u16 floorcol; }; -u32 convertTiles(u8 *dst, u8 *src, size_t srclen) +static u32 convertTiles(u8 *dst, u8 *src, size_t srclen) { int num_rooms = PD_BE32(*(u32 *) src); diff --git a/port/src/preprocess/gbi.c b/port/src/preprocess/gbi.c index 370246511..e6c371097 100644 --- a/port/src/preprocess/gbi.c +++ b/port/src/preprocess/gbi.c @@ -27,46 +27,46 @@ struct texaddr { u32 dst; }; -u32 m_Segments[16]; -u32 m_SrcVtxOffset; -u32 m_DstVtxOffset; +static u32 gbiSegments[16]; +static u32 srcVtxOffset; +static u32 dstVtxOffset; -struct texaddr m_TexAddrs[64]; -int m_NumTexAddr; +static struct texaddr texAddrs[64]; +static int numTexAddrs; void gbiReset(void) { - for (int i = 0; i < ARRAYCOUNT(m_Segments); i++) { - m_Segments[i] = 0; + for (int i = 0; i < ARRAYCOUNT(gbiSegments); i++) { + gbiSegments[i] = 0; } - m_SrcVtxOffset = 0; - m_DstVtxOffset = 0; - m_NumTexAddr = 0; + srcVtxOffset = 0; + dstVtxOffset = 0; + numTexAddrs = 0; } void gbiSetSegment(int segment, u32 offset) { - m_Segments[segment] = offset & 0x00ffffff; + gbiSegments[segment] = offset & 0x00ffffff; } void gbiSetVtx(u32 src_offset, u32 dst_offset) { - m_SrcVtxOffset = src_offset & 0x00ffffff; - m_DstVtxOffset = dst_offset & 0x00ffffff; + srcVtxOffset = src_offset & 0x00ffffff; + dstVtxOffset = dst_offset & 0x00ffffff; } void gbiAddTexAddr(u32 src_offset, u32 dst_offset) { - m_TexAddrs[m_NumTexAddr].src = src_offset & 0x00ffffff; - m_TexAddrs[m_NumTexAddr++].dst = dst_offset & 0x00ffffff; + texAddrs[numTexAddrs].src = src_offset & 0x00ffffff; + texAddrs[numTexAddrs++].dst = dst_offset & 0x00ffffff; } u32 gbiFindTexAddr(u32 src_offset) { - for (int i = 0; i < m_NumTexAddr; i++) { - if (m_TexAddrs[i].src == src_offset) - return m_TexAddrs[i].dst; + for (int i = 0; i < numTexAddrs; i++) { + if (texAddrs[i].src == src_offset) + return texAddrs[i].dst; } return 0; @@ -128,11 +128,11 @@ static u64 gbiRewriteAddr(u64 cmd, u8 opcode) offset = gbiFindTexAddr(offset); } else { - if (offset < m_SrcVtxOffset) { - sysFatalError("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, m_SrcVtxOffset); + if (offset < srcVtxOffset) { + sysFatalError("Tried to load data from offset 0x%x but segment starts at 0x%x\n", offset, srcVtxOffset); } - offset = offset - m_SrcVtxOffset + m_DstVtxOffset; + offset = offset - srcVtxOffset + dstVtxOffset; } } diff --git a/port/src/preprocess/misc.c b/port/src/preprocess/misc.c index f5c4d1c15..c3361e90b 100644 --- a/port/src/preprocess/misc.c +++ b/port/src/preprocess/misc.c @@ -13,7 +13,7 @@ #include "preprocess/common.h" -u8* preprocessAnimations(u8* data, u32 size, u32* outSize) +u8 *preprocessAnimations(u8* data, u32 size, u32* outSize) { // set the anim table pointers as well extern u8 *_animationsTableRomStart; @@ -38,10 +38,11 @@ u8* preprocessAnimations(u8* data, u32 size, u32* outSize) anim->data = 0xffffffff; } } - return 0; + + return NULL; } -u8* preprocessMpConfigs(u8* data, u32 size, u32* outSize) +u8 *preprocessMpConfigs(u8* data, u32 size, u32* outSize) { const u32 count = size / sizeof(struct mpconfig); struct mpconfig *cfg = (struct mpconfig *)data; @@ -71,38 +72,11 @@ u8* preprocessMpConfigs(u8* data, u32 size, u32* outSize) #endif } } - return 0; + + return NULL; } -u8* preprocessJpnFont(u8* data, u32 size, u32* outSize) -{ - // ??? - return 0; -} - -void preprocessALCMidiHdr(u8 *data, u32 size) -{ - ALCMidiHdr *hdr = (ALCMidiHdr *)data; - PD_SWAP_VAL(hdr->division); - for (s32 i = 0; i < ARRAYCOUNT(hdr->trackOffset); ++i) { - PD_SWAP_VAL(hdr->trackOffset[i]); - } -} - -u8* preprocessSequences(u8* data, u32 size, u32* outSize) -{ - struct seqtable *seq = (struct seqtable *)data; - PD_SWAP_VAL(seq->count); - - for (s16 i = 0; i < seq->count; ++i) { - PD_SWAP_VAL(seq->entries[i].binlen); - PD_SWAP_VAL(seq->entries[i].ziplen); - PD_SWAP_VAL(seq->entries[i].romaddr); - } - return 0; -} - -u8* preprocessTexturesList(u8* data, u32 size, u32* outSize) +u8 *preprocessTexturesList(u8* data, u32 size, u32* outSize) { struct texture *tex = (struct texture *)data; const u32 count = size / sizeof(*tex); @@ -116,5 +90,6 @@ u8* preprocessTexturesList(u8* data, u32 size, u32* outSize) tex->soundsurfacetype = tex->surfacetype; tex->surfacetype = tmp; } - return 0; + + return NULL; } diff --git a/port/src/preprocess/segaudio.c b/port/src/preprocess/segaudio.c index eaf5f67c4..56d7e3a13 100644 --- a/port/src/preprocess/segaudio.c +++ b/port/src/preprocess/segaudio.c @@ -6,58 +6,13 @@ #include "preprocess/common.h" -struct generic_adpcm_book { - s32 order; - s32 npredictors; - s16 book[128]; -}; - -struct generic_adpcm_loop { - u32 start; - u32 end; - u32 count; - s16 state[16]; -}; - -struct generic_raw_loop { - u32 start; - u32 end; - u32 count; -}; - -struct generic_envelope { - s32 attackTime; - s32 decayTime; - s32 releaseTime; - u8 attackVolume; - u8 decayVolume; -}; - -struct generic_keymap { - u8 velocityMin; - u8 velocityMax; - u8 keyMin; - u8 keyMax; - u8 keyBase; - s8 detune; -}; - struct n64_adpcm_waveinfo { - u32 loop; // ptr to struct generic_adpcm_loop - u32 book; // ptr to struct generic_adpcm_book -}; - -struct host_adpcm_waveinfo { - uintptr_t loop; // ptr to struct generic_adpcm_loop - uintptr_t book; // ptr to struct generic_adpcm_book + u32 loop; // ptr to ALADPCMloop + u32 book; // ptr to ALADPCMBook }; struct n64_raw_waveinfo { - u32 loop; // ptr to struct generic_raw_loop -}; - -struct host_raw_waveinfo { - uintptr_t loop; // ptr to struct generic_raw_loop + u32 loop; // ptr to ALRawLoop }; struct n64_wavetable { @@ -71,35 +26,15 @@ struct n64_wavetable { } waveInfo; }; -struct host_wavetable { - uintptr_t base; - s32 len; - u8 type; - u8 flags; - union { - struct host_adpcm_waveinfo adpcmWave; - struct host_raw_waveinfo rawWave; - } waveInfo; -}; - struct n64_sound { - u32 envelope; // ptr to struct generic_envelope - u32 keyMap; // ptr to struct generic_keymap + u32 envelope; // ptr to ALEnvelope + u32 keyMap; // ptr to ALKeyMap u32 wavetable; // ptr to struct n64_wavetable u8 samplePan; u8 sampleVolume; u8 flags; }; -struct host_sound { - uintptr_t envelope; // ptr to struct generic_envelope - uintptr_t keyMap; // ptr to struct generic_keymap - uintptr_t wavetable; // ptr to struct host_wavetable - u8 samplePan; - u8 sampleVolume; - u8 flags; -}; - struct n64_instrument { u8 volume; u8 pan; @@ -118,24 +53,6 @@ struct n64_instrument { u32 soundArray[1]; // ptr to struct n64_sound }; -struct host_instrument { - u8 volume; - u8 pan; - u8 priority; - u8 flags; - u8 tremType; - u8 tremRate; - u8 tremDepth; - u8 tremDelay; - u8 vibType; - u8 vibRate; - u8 vibDepth; - u8 vibDelay; - s16 bendRange; - s16 soundCount; - uintptr_t soundArray[1]; // ptr to struct host_sound -}; - struct n64_bank { s16 instCount; u8 flags; @@ -145,44 +62,29 @@ struct n64_bank { u32 instArray[1]; // ptr to struct n64_instrument }; -struct host_bank { - s16 instCount; - u8 flags; - u8 pad; - s32 sampleRate; - uintptr_t percussion; // ptr to struct host_instrument - uintptr_t instArray[1]; // ptr to struct host_instrument -}; - struct n64_bankfile { s16 revision; s16 bankCount; u32 bankArray[1]; // ptr to struct n64_bank }; -struct host_bankfile { - s16 revision; - s16 bankCount; - uintptr_t bankArray[1]; // ptr to struct host_bank -}; - // only proceeds to convert the next item if it's not already converted #define AL_NEXT_ITEM(field, func) { \ struct ptrmarker *marker = ptrFind(srcpos); \ if (marker == NULL) { \ - field = (dstpos); \ - ptrAdd(srcpos, field); \ + field = (void *)(uintptr_t)(dstpos); \ + ptrAdd(srcpos, (uintptr_t)(field)); \ dstpos = func(dst, dstpos, src, srcpos); \ } else { \ - field = marker->ptr_host; } \ + field = (void *)marker->ptr_host; } \ } -static int convertAudioEnvelope(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioEnvelope(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { - struct generic_envelope *n64_envelope = (struct generic_envelope *) &src[srcpos]; - struct generic_envelope *host_envelope = (struct generic_envelope *) &dst[dstpos]; + ALEnvelope *n64_envelope = (ALEnvelope *) &src[srcpos]; + ALEnvelope *host_envelope = (ALEnvelope *) &dst[dstpos]; - dstpos += sizeof(struct generic_envelope); + dstpos += sizeof(ALEnvelope); host_envelope->attackTime = PD_BE32(n64_envelope->attackTime); host_envelope->decayTime = PD_BE32(n64_envelope->decayTime); @@ -193,12 +95,12 @@ static int convertAudioEnvelope(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertAudioKeyMap(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioKeyMap(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { - struct generic_keymap *n64_keymap = (struct generic_keymap *) &src[srcpos]; - struct generic_keymap *host_keymap = (struct generic_keymap *) &dst[dstpos]; + ALKeyMap *n64_keymap = (ALKeyMap *) &src[srcpos]; + ALKeyMap *host_keymap = (ALKeyMap *) &dst[dstpos]; - dstpos += sizeof(struct generic_keymap); + dstpos += sizeof(ALKeyMap); host_keymap->velocityMin = n64_keymap->velocityMin; host_keymap->velocityMax = n64_keymap->velocityMax; @@ -210,12 +112,12 @@ static int convertAudioKeyMap(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertAudioAdpcmLoop(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioAdpcmLoop(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { - struct generic_adpcm_loop *n64_loop = (struct generic_adpcm_loop *) &src[srcpos]; - struct generic_adpcm_loop *host_loop = (struct generic_adpcm_loop *) &dst[dstpos]; + ALADPCMloop *n64_loop = (ALADPCMloop *) &src[srcpos]; + ALADPCMloop *host_loop = (ALADPCMloop *) &dst[dstpos]; - dstpos += sizeof(struct generic_adpcm_loop); + dstpos += sizeof(ALADPCMloop); host_loop->start = PD_BE32(n64_loop->start); host_loop->end = PD_BE32(n64_loop->end); @@ -228,12 +130,12 @@ static int convertAudioAdpcmLoop(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertAudioAdpcmBook(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioAdpcmBook(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { - struct generic_adpcm_book *n64_book = (struct generic_adpcm_book *) &src[srcpos]; - struct generic_adpcm_book *host_book = (struct generic_adpcm_book *) &dst[dstpos]; + ALADPCMBook *n64_book = (ALADPCMBook *) &src[srcpos]; + ALADPCMBook *host_book = (ALADPCMBook *) &dst[dstpos]; - dstpos += sizeof(struct generic_adpcm_book); + dstpos += sizeof(ALADPCMBook); host_book->order = PD_BE32(n64_book->order); host_book->npredictors = PD_BE32(n64_book->npredictors); @@ -245,12 +147,12 @@ static int convertAudioAdpcmBook(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertAudioRawLoop(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioRawLoop(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { - struct generic_raw_loop *n64_loop = (struct generic_raw_loop *) &src[srcpos]; - struct generic_raw_loop *host_loop = (struct generic_raw_loop *) &dst[dstpos]; + ALRawLoop *n64_loop = (ALRawLoop *) &src[srcpos]; + ALRawLoop *host_loop = (ALRawLoop *) &dst[dstpos]; - dstpos += sizeof(struct generic_raw_loop); + dstpos += sizeof(ALRawLoop); host_loop->start = PD_BE32(n64_loop->start); host_loop->end = PD_BE32(n64_loop->end); @@ -259,14 +161,14 @@ static int convertAudioRawLoop(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertAudioWaveTable(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioWaveTable(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { struct n64_wavetable *n64_wavetable = (struct n64_wavetable *) &src[srcpos]; - struct host_wavetable *host_wavetable = (struct host_wavetable *) &dst[dstpos]; + ALWaveTable *host_wavetable = (ALWaveTable *) &dst[dstpos]; - dstpos += sizeof(struct host_wavetable); + dstpos += sizeof(ALWaveTable); - host_wavetable->base = PD_BE32(n64_wavetable->base); + host_wavetable->base = (void *)(uintptr_t)PD_BE32(n64_wavetable->base); host_wavetable->len = PD_BE32(n64_wavetable->len); host_wavetable->type = n64_wavetable->type; host_wavetable->flags = n64_wavetable->flags; @@ -276,53 +178,53 @@ static int convertAudioWaveTable(u8 *dst, int dstpos, u8 *src, int srcpos) srcpos = PD_BE32(n64_wavetable->waveInfo.adpcmWave.loop); AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.loop, convertAudioAdpcmLoop); } else { - host_wavetable->waveInfo.adpcmWave.loop = 0; + host_wavetable->waveInfo.adpcmWave.loop = NULL; } if (n64_wavetable->waveInfo.adpcmWave.book) { srcpos = PD_BE32(n64_wavetable->waveInfo.adpcmWave.book); AL_NEXT_ITEM(host_wavetable->waveInfo.adpcmWave.book, convertAudioAdpcmBook); } else { - host_wavetable->waveInfo.adpcmWave.book = 0; + host_wavetable->waveInfo.adpcmWave.book = NULL; } } else if (host_wavetable->type == AL_RAW16_WAVE) { if (n64_wavetable->waveInfo.rawWave.loop) { srcpos = PD_BE32(n64_wavetable->waveInfo.rawWave.loop); AL_NEXT_ITEM(host_wavetable->waveInfo.rawWave.loop, convertAudioRawLoop); } else { - host_wavetable->waveInfo.rawWave.loop = 0; + host_wavetable->waveInfo.rawWave.loop = NULL; } } return dstpos; } -static int convertAudioSound(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioSound(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { struct n64_sound *n64_sound = (struct n64_sound *) &src[srcpos]; - struct host_sound *host_sound = (struct host_sound *) &dst[dstpos]; + ALSound *host_sound = (ALSound *) &dst[dstpos]; - dstpos += sizeof(struct host_sound); + dstpos += sizeof(ALSound); if (n64_sound->envelope) { srcpos = PD_BE32(n64_sound->envelope); AL_NEXT_ITEM(host_sound->envelope, convertAudioEnvelope); } else { - host_sound->envelope = 0; + host_sound->envelope = NULL; } if (n64_sound->keyMap) { srcpos = PD_BE32(n64_sound->keyMap); AL_NEXT_ITEM(host_sound->keyMap, convertAudioKeyMap); } else { - host_sound->keyMap = 0; + host_sound->keyMap = NULL; } if (n64_sound->wavetable) { srcpos = PD_BE32(n64_sound->wavetable); AL_NEXT_ITEM(host_sound->wavetable, convertAudioWaveTable); } else { - host_sound->wavetable = 0; + host_sound->wavetable = NULL; } host_sound->samplePan = n64_sound->samplePan; @@ -332,11 +234,11 @@ static int convertAudioSound(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertAudioInstrument(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioInstrument(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { struct n64_instrument *n64_instrument = (struct n64_instrument *) &src[srcpos]; - struct host_instrument *host_instrument = (struct host_instrument *) &dst[dstpos]; - int soundCount = PD_BE16(n64_instrument->soundCount); + ALInstrument *host_instrument = (ALInstrument *) &dst[dstpos]; + const s16 soundCount = PD_BE16(n64_instrument->soundCount); host_instrument->volume = n64_instrument->volume; host_instrument->pan = n64_instrument->pan; @@ -353,7 +255,7 @@ static int convertAudioInstrument(u8 *dst, int dstpos, u8 *src, int srcpos) host_instrument->bendRange = PD_BE16(n64_instrument->bendRange); host_instrument->soundCount = (soundCount); - dstpos = dstpos + sizeof(struct host_instrument) + sizeof(uintptr_t) * (soundCount - 1); + dstpos = dstpos + sizeof(ALInstrument) + sizeof(uintptr_t) * (soundCount - 1); for (int i = 0; i < soundCount; i++) { srcpos = PD_BE32(n64_instrument->soundArray[i]); @@ -363,18 +265,18 @@ static int convertAudioInstrument(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertAudioBank(u8 *dst, int dstpos, u8 *src, int srcpos) +static u32 convertAudioBank(u8 *dst, u32 dstpos, u8 *src, u32 srcpos) { struct n64_bank *n64_bank = (struct n64_bank *) &src[srcpos]; - struct host_bank *host_bank = (struct host_bank *) &dst[dstpos]; - int instCount = PD_BE16(n64_bank->instCount); + ALBank *host_bank = (ALBank *) &dst[dstpos]; + const s16 instCount = PD_BE16(n64_bank->instCount); host_bank->instCount = (instCount); host_bank->flags = n64_bank->flags; host_bank->pad = n64_bank->pad; host_bank->sampleRate = PD_BE32(n64_bank->sampleRate); - dstpos = dstpos + sizeof(struct host_bank) + sizeof(uintptr_t) * (instCount - 1); + dstpos = dstpos + sizeof(ALBank) + sizeof(uintptr_t) * (instCount - 1); if (n64_bank->percussion) { srcpos = PD_BE32(n64_bank->percussion); @@ -391,20 +293,19 @@ static int convertAudioBank(u8 *dst, int dstpos, u8 *src, int srcpos) return dstpos; } -static int convertAudioBankFile(u8 *dst, u8 *src) +static u32 convertAudioBankFile(u8 *dst, u8 *src) { struct n64_bankfile *n64_bankfile = (struct n64_bankfile *)src; - struct host_bankfile *host_bankfile = (struct host_bankfile *)dst; - int bankCount = PD_BE16(n64_bankfile->bankCount); + ALBankFile *host_bankfile = (ALBankFile *)dst; + const s16 bankCount = PD_BE16(n64_bankfile->bankCount); host_bankfile->revision = PD_BE16(n64_bankfile->revision); host_bankfile->bankCount = (bankCount); - - u32 dstpos = sizeof(struct host_bankfile) + sizeof(uintptr_t) * (bankCount - 1); + u32 dstpos = sizeof(ALBankFile) + sizeof(uintptr_t) * (bankCount - 1); for (int i = 0; i < bankCount; i++) { - host_bankfile->bankArray[i] = (dstpos); + host_bankfile->bankArray[i] = (void *)(uintptr_t)(dstpos); u32 srcpos = PD_BE32(n64_bankfile->bankArray[i]); dstpos = convertAudioBank(dst, dstpos, src, srcpos); } @@ -423,3 +324,28 @@ u8 *preprocessALBankFile(u8 *src, u32 size, u32 *outSize) return dst; } + + +u8 *preprocessALCMidiHdr(u8 *data, u32 size, u32 *outSize) +{ + ALCMidiHdr *hdr = (ALCMidiHdr *)data; + PD_SWAP_VAL(hdr->division); + for (s32 i = 0; i < ARRAYCOUNT(hdr->trackOffset); ++i) { + PD_SWAP_VAL(hdr->trackOffset[i]); + } + return NULL; +} + +u8 *preprocessSequences(u8* data, u32 size, u32 *outSize) +{ + struct seqtable *seq = (struct seqtable *)data; + PD_SWAP_VAL(seq->count); + + for (s16 i = 0; i < seq->count; ++i) { + PD_SWAP_VAL(seq->entries[i].binlen); + PD_SWAP_VAL(seq->entries[i].ziplen); + PD_SWAP_VAL(seq->entries[i].romaddr); + } + + return NULL; +} diff --git a/port/src/preprocess/segfonts.c b/port/src/preprocess/segfonts.c index 6d37bd532..7b3ab1f7c 100644 --- a/port/src/preprocess/segfonts.c +++ b/port/src/preprocess/segfonts.c @@ -6,7 +6,7 @@ #include "preprocess/common.h" -struct n64fontchar { +struct n64_fontchar { u8 index; s8 baseline; u8 height; @@ -15,16 +15,7 @@ struct n64fontchar { u32 pixeldata; }; -struct hostfontchar { - u8 index; - s8 baseline; - u8 height; - u8 width; - s32 kerningindex; - uintptr_t pixeldata; -}; - -struct n64fontcharjpn { +struct n64_fontcharjpn { u16 index; s8 baseline; u8 height; @@ -33,21 +24,6 @@ struct n64fontcharjpn { u32 pixeldata; }; -struct hostfontcharjpn { - u16 index; - s8 baseline; - u8 height; - u8 width; - s16 kerningindex; - uintptr_t pixeldata; -}; - -struct fontdef { - const char *name; - u32 offsets[3]; - int pal_extra_chars; -}; - u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) { int num_chars = 94; @@ -63,7 +39,7 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) } #endif - size_t dstlen = srclen - (num_chars * sizeof(struct n64fontchar)) + (num_chars * sizeof(struct hostfontchar)) + 0x20; + size_t dstlen = srclen - (num_chars * sizeof(struct n64_fontchar)) + (num_chars * sizeof(struct fontchar)) + 0x20; u8* dst = sysMemZeroAlloc(dstlen); // Kerning table @@ -79,9 +55,9 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) // Character table #if VERSION == VERSION_JPN_FINAL - struct n64fontcharjpn *src_char_table = (struct n64fontcharjpn *) &src[src_offset]; + struct n64_fontcharjpn *src_char_table = (struct n64_fontcharjpn *) &src[src_offset]; struct hostfontcharjpn *dst_char_table = (struct hostfontcharjpn *) &dst[dst_offset]; - u32 diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64fontcharjpn)); + u32 diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64_fontcharjpn)); for (int i = 0; i < num_chars; i++) { dst_char_table[i].index = PD_BE16(src_char_table[i].index); @@ -89,15 +65,15 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) dst_char_table[i].height = src_char_table[i].height; dst_char_table[i].width = src_char_table[i].width; dst_char_table[i].kerningindex = PD_BE16(src_char_table[i].kerningindex); - dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? PD_BE32(src_char_table[i].pixeldata) + diff : 0; + dst_char_table[i].pixeldata = (void *)(uintptr_t)(src_char_table[i].pixeldata ? PD_BE32(src_char_table[i].pixeldata) + diff : 0); } - src_offset += num_chars * sizeof(struct n64fontcharjpn); + src_offset += num_chars * sizeof(struct n64_fontcharjpn); dst_offset += num_chars * sizeof(struct hostfontcharjpn); #else - struct n64fontchar *src_char_table = (struct n64fontchar *) &src[src_offset]; - struct hostfontchar *dst_char_table = (struct hostfontchar *) &dst[dst_offset]; - u32 diff = (dst_offset + num_chars * sizeof(struct hostfontchar)) - (src_offset + num_chars * sizeof(struct n64fontchar)); + struct n64_fontchar *src_char_table = (struct n64_fontchar *) &src[src_offset]; + struct fontchar *dst_char_table = (struct fontchar *) &dst[dst_offset]; + u32 diff = (dst_offset + num_chars * sizeof(struct fontchar)) - (src_offset + num_chars * sizeof(struct n64_fontchar)); for (int i = 0; i < num_chars; i++) { dst_char_table[i].index = src_char_table[i].index; @@ -105,11 +81,11 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) dst_char_table[i].height = src_char_table[i].height; dst_char_table[i].width = src_char_table[i].width; dst_char_table[i].kerningindex = PD_BE32(src_char_table[i].kerningindex); - dst_char_table[i].pixeldata = src_char_table[i].pixeldata ? PD_BE32(src_char_table[i].pixeldata) + diff : 0; + dst_char_table[i].pixeldata = (void *)(uintptr_t)(src_char_table[i].pixeldata ? PD_BE32(src_char_table[i].pixeldata) + diff : 0); } - src_offset += num_chars * sizeof(struct n64fontchar); - dst_offset += num_chars * sizeof(struct hostfontchar); + src_offset += num_chars * sizeof(struct n64_fontchar); + dst_offset += num_chars * sizeof(struct fontchar); #endif // Pixel data @@ -120,3 +96,9 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) return dst; } + +u8 *preprocessJpnFont(u8* data, u32 size, u32* outSize) +{ + // ??? + return NULL; +} diff --git a/src/include/types.h b/src/include/types.h index da5d058b4..50d9df1a5 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -538,6 +538,7 @@ struct modelrodata_type11 { // type 0x11 u32 unk0c; u32 unk10; void *unk14; + u32 unk18; }; struct modelrodata_toggle { // type 0x12 @@ -548,6 +549,7 @@ struct modelrodata_toggle { // type 0x12 struct modelrodata_positionheld { // type 0x15 struct coord pos; s16 mtxindex; + s32 unk10; }; struct modelrodata_stargunfire { // type 0x16 @@ -2844,6 +2846,7 @@ struct coverdefinition { struct coord pos; struct coord look; u16 flags; + u16 unk1a; }; struct cover { diff --git a/src/lib/snd.c b/src/lib/snd.c index 558c068bb..ed76b4afa 100644 --- a/src/lib/snd.c +++ b/src/lib/snd.c @@ -1697,7 +1697,7 @@ bool seqPlay(struct seqinstance *seq, s32 tracknum) } #ifndef PLATFORM_N64 - preprocessALCMidiHdr(binstart, ziplen); + preprocessALCMidiHdr(binstart, ziplen, NULL); #endif #if VERSION < VERSION_NTSC_1_0 From 421ac0af794f59b89aaa583f2083fe9333be9a87 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 13:18:02 +0100 Subject: [PATCH 73/81] port: 64-bit: fix extra fields in modelrodata_type11 --- port/src/preprocess/filemodel.c | 5 +++-- src/include/types.h | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/port/src/preprocess/filemodel.c b/port/src/preprocess/filemodel.c index 0d9ca077e..c2ff8c100 100644 --- a/port/src/preprocess/filemodel.c +++ b/port/src/preprocess/filemodel.c @@ -565,8 +565,9 @@ static u32 convertContent(u8 *dst, u8 *src, u32 src_file_len) dst_type11->unk08 = PD_BE32(src_type11->unk08); dst_type11->unk0c = PD_BE32(src_type11->unk0c); dst_type11->unk10 = PD_BE32(src_type11->unk10); - dst_type11->unk14 = (void *)(uintptr_t)PD_BE32(src_type11->extra1); - dst_type11->unk18 = PD_BE32(src_type11->extra2); + dst_type11->unk14 = NULL; + dst_type11->unk18 = PD_BE32(src_type11->extra1); + dst_type11->unk1c = PD_BE32(src_type11->extra2); dstpos += sizeof(*dst_type11); break; case CT_RODATA_TOGGLE: diff --git a/src/include/types.h b/src/include/types.h index 50d9df1a5..2936c93f9 100644 --- a/src/include/types.h +++ b/src/include/types.h @@ -539,6 +539,7 @@ struct modelrodata_type11 { // type 0x11 u32 unk10; void *unk14; u32 unk18; + u32 unk1c; }; struct modelrodata_toggle { // type 0x12 From fdbd1667ad4df9b45304a9cfb26f967bfd6094ef Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 13:52:11 +0100 Subject: [PATCH 74/81] port: build: name executables and build folders according to arch --- Makefile.port | 43 +++++++++++++++++++++++++++++-------------- 1 file changed, 29 insertions(+), 14 deletions(-) diff --git a/Makefile.port b/Makefile.port index 93f71a921..21a7c4f87 100644 --- a/Makefile.port +++ b/Makefile.port @@ -79,32 +79,42 @@ ifeq ($(TARGET_PLATFORM),) TARGET_PLATFORM := $(HOST_PLATFORM) endif -ifeq (,$(findstring clean,$(MAKECMDGOALS))) - $(info Host platform: $(HOST_PLATFORM)) - $(info Target platform: $(TARGET_PLATFORM)) -endif +# Get the arch part from the platform designator. +HOST_ARCH := $(word 1,$(subst -, ,$(HOST_PLATFORM))) +TARGET_ARCH := $(word 1,$(subst -, ,$(TARGET_PLATFORM))) -# Set whether the target arch is 64- or 32-bit. +# Gather platform parameters. +# Whether the platform is 64 bit. ifneq (,$(findstring 64,$(TARGET_PLATFORM))$(findstring armv8,$(TARGET_PLATFORM))) - TARGET_64BIT = 1 + TARGET_64BIT := 1 else - TARGET_64BIT = 0 + TARGET_64BIT := 0 +endif +# Whether the target is big-endian or little-endian. +TARGET_BIG_ENDIAN = 0 # TODO +# Executable extension. +ifneq (,$(findstring windows,$(TARGET_PLATFORM))) + BIN_EXTENSION := .exe +else + BIN_EXTENSION := endif -# Set whether the target is big-endian or little-endian. -TARGET_BIG_ENDIAN = 0 # TODO +ifeq (,$(findstring clean,$(MAKECMDGOALS))) + $(info Host platform: $(HOST_PLATFORM) (arch $(HOST_ARCH))) + $(info Target platform: $(TARGET_PLATFORM) (arch $(TARGET_ARCH))) +endif # The VERSION constant is used in the source to handle version-specific code. ifeq ($(ROMID),ntsc-final) - BIN_NAME = pd.exe + BIN_NAME = pd.$(TARGET_ARCH)$(BIN_EXTENSION) VERSION = 2 IS_PAL = 0 else ifeq ($(ROMID),pal-final) - BIN_NAME = pd.pal.exe + BIN_NAME = pd.pal.$(TARGET_ARCH)$(BIN_EXTENSION) VERSION = 4 IS_PAL = 1 else ifeq ($(ROMID),jpn-final) - BIN_NAME = pd.jpn.exe + BIN_NAME = pd.jpn.$(TARGET_ARCH)$(BIN_EXTENSION) VERSION = 5 IS_PAL = 0 else @@ -114,6 +124,7 @@ endif VERSION_HASH := $(shell git rev-parse --short HEAD) VERSION_BRANCH := $(shell git rev-parse --abbrev-ref HEAD) VERSION_TARGET := $(TARGET_PLATFORM) +VERSION_ARCH := $(TARGET_ARCH) VERSION_ROMID := $(ROMID) ifeq ($(VERSION_BRANCH),) @@ -123,10 +134,13 @@ ifeq ($(VERSION_BRANCH),HEAD) VERSION_BRANCH := port-custom endif +BUILDID := $(ROMID)-port-$(TARGET_ARCH) + DEFINES := \ VERSION=$(VERSION) \ VERSION_HASH=\"$(VERSION_HASH)\" \ VERSION_TARGET=\"$(VERSION_TARGET)\" \ + VERSION_ARCH=\"$(VERSION_ARCH)\" \ VERSION_ROMID=\"$(VERSION_ROMID)\" \ VERSION_BRANCH=\"$(VERSION_BRANCH)\" \ MATCHING=0 \ @@ -146,7 +160,7 @@ endif C_DEFINES := $(foreach d,$(DEFINES),-D$(d)) A_DIR := src/assets/$(ROMID) -B_DIR := build/$(ROMID)-port +B_DIR := build/$(BUILDID) G_DIR := src/generated/$(ROMID) ifneq (,$(findstring windows,$(TARGET_PLATFORM))) @@ -277,6 +291,7 @@ LDFLAGS := $(TARGET_LDFLAGS) # Make ROMID available as an environment variable to all tooling. # (We use this a lot) export ROMID +export BUILDID BIN := $(B_DIR)/$(BIN_NAME) @@ -333,7 +348,7 @@ $(B_DIR)/%.res: dist/windows/%.rc # Clean rules clean: - rm -rf build/$(ROMID)-port + rm -rf build/$(BUILDID) allclean: rm -rf build/* From d5482f345325278b6b3123f5fbd1c65f597bf632 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 13:53:30 +0100 Subject: [PATCH 75/81] port: build: name executables and build folders according to target platform --- Makefile.port | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile.port b/Makefile.port index 21a7c4f87..a9fea91bd 100644 --- a/Makefile.port +++ b/Makefile.port @@ -134,7 +134,7 @@ ifeq ($(VERSION_BRANCH),HEAD) VERSION_BRANCH := port-custom endif -BUILDID := $(ROMID)-port-$(TARGET_ARCH) +BUILDID := $(ROMID)-$(TARGET_PLATFORM) DEFINES := \ VERSION=$(VERSION) \ From 3f887b2ecf2d4694835024f660d5867fcd74f641 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 13:53:52 +0100 Subject: [PATCH 76/81] port: 64-bit: shrink audio bank allocation after loading --- port/include/system.h | 1 + port/src/preprocess/filelang.c | 2 +- port/src/preprocess/segaudio.c | 17 ++++++++++++++--- port/src/system.c | 5 +++++ 4 files changed, 21 insertions(+), 4 deletions(-) diff --git a/port/include/system.h b/port/include/system.h index 84d568382..dc581dfb9 100644 --- a/port/include/system.h +++ b/port/include/system.h @@ -32,6 +32,7 @@ void sysGetHomePath(char *outPath, const u32 outLen); void *sysMemAlloc(const u32 size); void *sysMemZeroAlloc(const u32 size); +void *sysMemRealloc(void *ptr, const u32 newSize); void sysMemFree(void *ptr); // hns is specified in 100ns units diff --git a/port/src/preprocess/filelang.c b/port/src/preprocess/filelang.c index 841dbffe1..9869202fb 100644 --- a/port/src/preprocess/filelang.c +++ b/port/src/preprocess/filelang.c @@ -31,7 +31,7 @@ static int getNumStrings(u8 *src, size_t len) return 1; } -u32 convertLangFile(u8 *dst, u8 *src, size_t srclen) +static u32 convertLangFile(u8 *dst, u8 *src, size_t srclen) { // Convert it u32 *src_offsets = (u32 *) src; diff --git a/port/src/preprocess/segaudio.c b/port/src/preprocess/segaudio.c index 56d7e3a13..3ddbdf5f3 100644 --- a/port/src/preprocess/segaudio.c +++ b/port/src/preprocess/segaudio.c @@ -316,11 +316,22 @@ static u32 convertAudioBankFile(u8 *dst, u8 *src) u8 *preprocessALBankFile(u8 *src, u32 size, u32 *outSize) { ptrReset(); - u32 dstlen = size * 3; + + const u32 dstlen = size * 3; // this should overshoot any possible bank size, but * 2 also works for vanilla banks u8 *dst = sysMemZeroAlloc(dstlen); - *outSize = convertAudioBankFile(dst, src); - *outSize = ALIGN16(*outSize); + u32 reallen = convertAudioBankFile(dst, src); + if (reallen > dstlen || ALIGN16(reallen) > dstlen) { + sysFatalError("overflow when trying to preprocess an ALBankFile, size %u dstlen %u reallen %u", size, dstlen, reallen); + } + + reallen = ALIGN16(reallen); + + if (reallen < dstlen) { + dst = sysMemRealloc(dst, reallen); + } + + *outSize = reallen; return dst; } diff --git a/port/src/system.c b/port/src/system.c index 16b689c47..60d94f592 100644 --- a/port/src/system.c +++ b/port/src/system.c @@ -288,6 +288,11 @@ void *sysMemZeroAlloc(const u32 size) return calloc(1, size); } +void *sysMemRealloc(void *ptr, const u32 newSize) +{ + return realloc(ptr, newSize); +} + void sysMemFree(void *ptr) { free(ptr); From 345da23ebef12d9eb9b00f3d284b5f579937e2d7 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 13:57:11 +0100 Subject: [PATCH 77/81] ci: re-enable CI --- .github/workflows/c-cpp.yml | 60 ++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index f75e022c6..b06ef50f1 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -2,9 +2,9 @@ name: C/C++ CI on: push: - branches: [ "port-x64" ] + branches: [ "port" ] pull_request: - branches: [ "port-x64" ] + branches: [ "port" ] workflow_dispatch: jobs: @@ -27,18 +27,18 @@ jobs: mingw-w64-i686-zlib - name: Checkout repository uses: actions/checkout@v4 - - name: Build pd.exe + - name: Build pd.i686.exe run: make -f Makefile.port -j - - name: Build pd.pal.exe + - name: Build pd.pal.i686.exe run: make -f Makefile.port -j ROMID=pal-final - - name: Build pd.jpn.exe + - name: Build pd.jpn.i686.exe run: make -f Makefile.port -j ROMID=jpn-final - name: Prepare artifact for packaging run: | mkdir -p bin/data - cp build/ntsc-final-port/pd.exe bin/ - cp build/pal-final-port/pd.pal.exe bin/ - cp build/jpn-final-port/pd.jpn.exe bin/ + cp build/ntsc-final-port/pd.i686.exe bin/ + cp build/pal-final-port/pd.pal.i686.exe bin/ + cp build/jpn-final-port/pd.jpn.i686.exe bin/ cp /mingw32/bin/{SDL2.dll,zlib1.dll,libgcc_s_dw2-1.dll,libwinpthread-1.dll} bin/ touch bin/data/put_your_rom_here.txt - name: Upload artifact @@ -58,18 +58,18 @@ jobs: sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-dev:i386 zlib1g-dev:i386 - name: Checkout repository uses: actions/checkout@v4 - - name: Build pd.exe + - name: Build pd.i686 run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 - - name: Build pd.pal.exe + - name: Build pd.pal.i686 run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 ROMID=pal-final - - name: Build pd.jpn.exe + - name: Build pd.jpn.i686 run: make -f Makefile.port TARGET_PLATFORM=i686-linux -j2 ROMID=jpn-final - name: Prepare artifact for packaging run: | mkdir -p bin/data - cp build/ntsc-final-port/pd.exe bin/pd - cp build/pal-final-port/pd.pal.exe bin/pd.pal - cp build/jpn-final-port/pd.jpn.exe bin/pd.jpn + cp build/ntsc-final-port/pd.i686 bin/pd + cp build/pal-final-port/pd.pal.i686 bin/pd.pal + cp build/jpn-final-port/pd.jpn.i686 bin/pd.jpn touch bin/data/put_your_rom_here.txt - name: Upload artifact uses: actions/upload-artifact@v4 @@ -98,18 +98,18 @@ jobs: mingw-w64-x86_64-zlib - name: Checkout repository uses: actions/checkout@v4 - - name: Build pd.exe + - name: Build pd.x86_64.exe run: make -f Makefile.port -j - - name: Build pd.pal.exe + - name: Build pd.pal.x86_64.exe run: make -f Makefile.port -j ROMID=pal-final - - name: Build pd.jpn.exe + - name: Build pd.jpn.x86_64.exe run: make -f Makefile.port -j ROMID=jpn-final - name: Prepare artifact for packaging run: | mkdir -p bin/data - cp build/ntsc-final-port/pd.exe bin/ - cp build/pal-final-port/pd.pal.exe bin/ - cp build/jpn-final-port/pd.jpn.exe bin/ + cp build/ntsc-final-port/pd.x86_64.exe bin/ + cp build/pal-final-port/pd.pal.x86_64.exe bin/ + cp build/jpn-final-port/pd.jpn.x86_64.exe bin/ cp /mingw64/bin/{SDL2.dll,zlib1.dll,libwinpthread-1.dll,libgcc_s_seh-1.dll} bin/ touch bin/data/put_your_rom_here.txt - name: Upload artifact @@ -129,18 +129,18 @@ jobs: sudo apt-get install git gcc g++ gcc-multilib g++-multilib make libsdl2-dev zlib1g-dev libsdl2-2.0-0 - name: Checkout repository uses: actions/checkout@v4 - - name: Build pd.exe + - name: Build pd.x86_64 run: make -f Makefile.port TARGET_PLATFORM=x86_64-linux -j2 - - name: Build pd.pal.exe + - name: Build pd.pal.x86_64 run: make -f Makefile.port TARGET_PLATFORM=x86_64-linux -j2 ROMID=pal-final - - name: Build pd.jpn.exe + - name: Build pd.jpn.x86_64 run: make -f Makefile.port TARGET_PLATFORM=x86_64-linux -j2 ROMID=jpn-final - name: Prepare artifact for packaging run: | mkdir -p bin/data - cp build/ntsc-final-port/pd.exe bin/pd - cp build/pal-final-port/pd.pal.exe bin/pd.pal - cp build/jpn-final-port/pd.jpn.exe bin/pd.jpn + cp build/ntsc-final-port/pd.x86_64 bin/pd + cp build/pal-final-port/pd.pal.x86_64 bin/pd.pal + cp build/jpn-final-port/pd.jpn.x86_64 bin/pd.jpn touch bin/data/put_your_rom_here.txt - name: Upload artifact uses: actions/upload-artifact@v4 @@ -187,7 +187,7 @@ jobs: publish-latest-build: runs-on: ubuntu-latest - if: github.ref == 'refs/heads/port-x64' + if: github.ref == 'refs/heads/port' needs: [build-i686-windows, build-i686-linux, build-x86_64-windows, build-x86_64-linux, build-flatpak-bundle] permissions: contents: write @@ -208,6 +208,6 @@ jobs: zip -r ../ci-release/pd-x86_64-windows.zip pd-x86_64-windows mv io.github.fgsfdsfgs.perfect_dark.flatpak/io.github.fgsfdsfgs.perfect_dark.flatpak ../ci-release/ popd - git tag --force ci-dev-build-x64 port-x64 - git push --force origin ci-dev-build-x64 - gh release upload --clobber ci-dev-build-x64 ci-release/* + git tag --force ci-dev-build port + git push --force origin ci-dev-build + gh release upload --clobber ci-dev-build ci-release/* From 420a1b52c183d72273e1d63ac550f41d9a81fe2e Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 13:58:37 +0100 Subject: [PATCH 78/81] ci: re-enable CI (2) --- .github/workflows/c-cpp.yml | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index b06ef50f1..d9904c222 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -36,9 +36,9 @@ jobs: - name: Prepare artifact for packaging run: | mkdir -p bin/data - cp build/ntsc-final-port/pd.i686.exe bin/ - cp build/pal-final-port/pd.pal.i686.exe bin/ - cp build/jpn-final-port/pd.jpn.i686.exe bin/ + cp build/ntsc-final-i686-windows/pd.i686.exe bin/ + cp build/pal-final-i686-windows/pd.pal.i686.exe bin/ + cp build/jpn-final-i686-windows/pd.jpn.i686.exe bin/ cp /mingw32/bin/{SDL2.dll,zlib1.dll,libgcc_s_dw2-1.dll,libwinpthread-1.dll} bin/ touch bin/data/put_your_rom_here.txt - name: Upload artifact @@ -67,9 +67,9 @@ jobs: - name: Prepare artifact for packaging run: | mkdir -p bin/data - cp build/ntsc-final-port/pd.i686 bin/pd - cp build/pal-final-port/pd.pal.i686 bin/pd.pal - cp build/jpn-final-port/pd.jpn.i686 bin/pd.jpn + cp build/ntsc-final-i686-linux/pd.i686 bin/pd + cp build/pal-final-i686-linux/pd.pal.i686 bin/pd.pal + cp build/jpn-final-i686-linux/pd.jpn.i686 bin/pd.jpn touch bin/data/put_your_rom_here.txt - name: Upload artifact uses: actions/upload-artifact@v4 @@ -107,9 +107,9 @@ jobs: - name: Prepare artifact for packaging run: | mkdir -p bin/data - cp build/ntsc-final-port/pd.x86_64.exe bin/ - cp build/pal-final-port/pd.pal.x86_64.exe bin/ - cp build/jpn-final-port/pd.jpn.x86_64.exe bin/ + cp build/ntsc-final-x86_64-windows/pd.x86_64.exe bin/ + cp build/pal-final-x86_64-windows/pd.pal.x86_64.exe bin/ + cp build/jpn-final-x86_64-windows/pd.jpn.x86_64.exe bin/ cp /mingw64/bin/{SDL2.dll,zlib1.dll,libwinpthread-1.dll,libgcc_s_seh-1.dll} bin/ touch bin/data/put_your_rom_here.txt - name: Upload artifact @@ -138,9 +138,9 @@ jobs: - name: Prepare artifact for packaging run: | mkdir -p bin/data - cp build/ntsc-final-port/pd.x86_64 bin/pd - cp build/pal-final-port/pd.pal.x86_64 bin/pd.pal - cp build/jpn-final-port/pd.jpn.x86_64 bin/pd.jpn + cp build/ntsc-final-x86_64-linux/pd.x86_64 bin/pd + cp build/pal-final-x86_64-linux/pd.pal.x86_64 bin/pd.pal + cp build/jpn-final-x86_64-linux/pd.jpn.x86_64 bin/pd.jpn touch bin/data/put_your_rom_here.txt - name: Upload artifact uses: actions/upload-artifact@v4 From 36f9e5930440ccb1cf585f4abd84562f3a2a5c78 Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 14:05:43 +0100 Subject: [PATCH 79/81] port: 64-bit: fix jpn builds --- port/src/preprocess/segfonts.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/port/src/preprocess/segfonts.c b/port/src/preprocess/segfonts.c index 7b3ab1f7c..20dbdc7ec 100644 --- a/port/src/preprocess/segfonts.c +++ b/port/src/preprocess/segfonts.c @@ -56,8 +56,8 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) // Character table #if VERSION == VERSION_JPN_FINAL struct n64_fontcharjpn *src_char_table = (struct n64_fontcharjpn *) &src[src_offset]; - struct hostfontcharjpn *dst_char_table = (struct hostfontcharjpn *) &dst[dst_offset]; - u32 diff = (dst_offset + num_chars * sizeof(struct hostfontcharjpn)) - (src_offset + num_chars * sizeof(struct n64_fontcharjpn)); + struct fontchar *dst_char_table = (struct fontchar *) &dst[dst_offset]; + u32 diff = (dst_offset + num_chars * sizeof(struct fontchar)) - (src_offset + num_chars * sizeof(struct n64_fontcharjpn)); for (int i = 0; i < num_chars; i++) { dst_char_table[i].index = PD_BE16(src_char_table[i].index); @@ -69,7 +69,7 @@ u8 *preprocessFont(u8 *src, u32 srclen, u32 *outSize) } src_offset += num_chars * sizeof(struct n64_fontcharjpn); - dst_offset += num_chars * sizeof(struct hostfontcharjpn); + dst_offset += num_chars * sizeof(struct fontchar); #else struct n64_fontchar *src_char_table = (struct n64_fontchar *) &src[src_offset]; struct fontchar *dst_char_table = (struct fontchar *) &dst[dst_offset]; From 58e64ebfc9af84bb1024f386758d66ad020cca3f Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 14:19:12 +0100 Subject: [PATCH 80/81] port: flatpak: launch the x86_64 executable for now --- dist/linux/io.github.fgsfdsfgs.perfect_dark.sh | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/dist/linux/io.github.fgsfdsfgs.perfect_dark.sh b/dist/linux/io.github.fgsfdsfgs.perfect_dark.sh index 0e163c2a9..28ff8213b 100644 --- a/dist/linux/io.github.fgsfdsfgs.perfect_dark.sh +++ b/dist/linux/io.github.fgsfdsfgs.perfect_dark.sh @@ -10,14 +10,15 @@ done # Default to pd as executable but switch to jpn/pal if the NTSC rom # is missing but JPN/PAL are present. -executable="pd" +# TODO: Other arch +executable="pd.x86_64" if [ -f ${XDG_DATA_HOME}/roms/pd.ntsc-final.z64 ] | \ [ -f ${XDG_DATA_HOME}/roms/pd.ntsc-1.0.z64 ]; then - executable="pd" + executable="pd.x86_64" elif [ -f ${XDG_DATA_HOME}/roms/pd.jpn-final.z64 ]; then - executable="pd.jpn" + executable="pd.jpn.x86_64" elif [ -f ${XDG_DATA_HOME}/roms/pd.pal-final.z64 ]; then - executable="pd.pal" + executable="pd.pal.x86_64" fi # If first parameter passed to this script is one of the pd executables, From 91c43385dd6c653f3afa5445d7ee6245f35e2d9b Mon Sep 17 00:00:00 2001 From: fgsfds Date: Tue, 12 Nov 2024 14:34:40 +0100 Subject: [PATCH 81/81] update README.md --- README.md | 46 ++++++++++++++++++++++++++-------------------- 1 file changed, 26 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index 020f75025..8f3af136e 100644 --- a/README.md +++ b/README.md @@ -35,14 +35,16 @@ There are minor graphics- and gameplay-related issues, and possibly occasional c * in practice the game will have issues running faster than ~165 FPS, so use VSync or `Video.FramerateLimit` to cap it. * emulate the Transfer Pak functionality the game has on the Nintendo 64 to unlock some cheats automatically. -Currently only 32-bit platforms are supported, namely x86 Windows and Linux. -Note that 32-bit binaries will still work on 64-bit versions of those platforms, -though you might have to install some additional libraries. +Currently both 32-bit and 64-bit platforms should be supported. +The port is tested on i686 and x86_64, both on Windows and on Linux. +ARM platforms might be supported, but are mostly untested. ## Download Latest [automatic builds](https://github.com/fgsfdsfgs/perfect_dark/releases/tag/ci-dev-build) for supported platforms: +* [x86_64-windows](https://github.com/fgsfdsfgs/perfect_dark/releases/download/ci-dev-build/pd-x86_64-windows.zip) * [i686-windows](https://github.com/fgsfdsfgs/perfect_dark/releases/download/ci-dev-build/pd-i686-windows.zip) +* [x86_64-linux](https://github.com/fgsfdsfgs/perfect_dark/releases/download/ci-dev-build/pd-x86_64-linux.tar.gz) * [i686-linux](https://github.com/fgsfdsfgs/perfect_dark/releases/download/ci-dev-build/pd-i686-linux.tar.gz) If you are looking for netplay builds (the `port-net` branch), see [this link](https://github.com/fgsfdsfgs/perfect_dark/blob/port-net/README.md#download). @@ -51,13 +53,15 @@ If you are looking for netplay builds (the `port-net` branch), see [this link](h You must already have a Perfect Dark ROM to run the game, as specified above. -1. Create a directory named `data` next to `pd.exe` if it's not there. +This assumes that you're using an x86_64 build. If you aren't, replace `x86_64` below with your arch (e.g. `i686`). + +1. Create a directory named `data` next to `pd.x86_64` if it's not there. 2. Put your Perfect Dark NTSC ROM named `pd.ntsc-final.z64` into it. -3. Run `pd.exe`. +3. Run the `pd.x86_64` executable. If you want to use a PAL or JPN ROM instead, put them into the `data` directory and run the appropriate executable: -* PAL: ROM name `pd.pal-final.z64`, EXE name `pd.pal.exe`. -* JPN: ROM name `pd.jpn-final.z64`, EXE name `pd.jpn.exe`. +* PAL: ROM name `pd.pal-final.z64`, executable name `pd.pal.x86_64`. +* JPN: ROM name `pd.jpn-final.z64`, executable name `pd.jpn.x86_64`. Optionally, you can also put your Perfect Dark for GameBoy Color ROM named `pd.gbc` in the `data` directory if you want to emulate having the Nintendo 64's Transfer Pak and unlock some cheats automatically. @@ -99,44 +103,46 @@ Controls can be rebound in `pd.ini`. Default control scheme is as follows: ### Windows 1. Install [MSYS2](https://www.msys2.org). -2. Open the `MINGW32` prompt. (**NOTE:** _not_ the `MSYS` prompt or the `MINGW64` prompt) +2. Open the `MINGW64` prompt if building for x86_64, or the `MINGW32` prompt if building for i686. (**NOTE:** _do not_ use the `MSYS` prompt) 3. Install dependencies: - `pacman -S mingw-w64-i686-toolchain mingw-w64-i686-SDL2 mingw-w64-i686-zlib make git` + `pacman -S mingw-w64-x86_64-toolchain mingw-w64-x86_64-SDL2 mingw-w64-x86_64-zlib mingw-w64-i686-toolchain mingw-w64-i686-SDL2 mingw-w64-i686-zlib make git` 4. Get the source code: `git clone --recursive https://github.com/fgsfdsfgs/perfect_dark.git && cd perfect_dark` 5. Run `make -f Makefile.port`. * Add ` ROMID=pal-final` or ` ROMID=jpn-final` at the end of the command if you want to build a PAL or JPN executable respectively. -6. The resulting executable will be at `build/ntsc-final-port/pd.exe`. +6. The resulting executable will be at `build/ntsc-final-x86_64-windows/pd.x86_64.exe` (or at `build/ntsc-final-i686-windows/pd.i686.exe` if building for i686). 7. If you don't know where you downloaded the source to, you can run `explorer .` to open the current directory. ### Linux -1. Ensure you have gcc, g++ (version 10.0+) and 32-bit versions of SDL2 (version 2.0.12+), libGL and ZLib installed on your system. - * On a 64-bit system you also need to have `gcc-multilib` and `g++-multilib` (or your distro's analogues) installed. +1. Ensure you have gcc, g++ (version 10.0+) and SDL2 (version 2.0.12+), libGL and ZLib installed on your system. + * If you wish to crosscompile, you will also need to have libraries and compilers for the target platform installed, e.g. `gcc-multilib` and `g++-multilib` for x86_64 -> i686 crosscompilation. 2. Get the source code: `git clone --recursive https://github.com/fgsfdsfgs/perfect_dark.git && cd perfect_dark` 3. Run the following command: - * On a 64-bit system: ```make -f Makefile.port TARGET_PLATFORM=i686-linux``` - * On a 32-bit system: ```make -f Makefile.port``` + * ```make -f Makefile.port``` * Add ` ROMID=pal-final` or ` ROMID=jpn-final` at the end of the command if you want to build a PAL or JPN executable respectively. -4. The resulting executable will be at `build/ntsc-final-port/pd.exe`. + * Add ` TARGET_PLATFORM=your-target` at the end of the command if you want to crosscompile. +4. The resulting executable will be at `build/ntsc-final-/pd.` (for example `build/ntsc-final-x86_64-linux/pd.x86_64`). -Currently only `i686-linux` and `i686-windows` are supported, using `gcc -m32` and `i686-w64-mingw32-gcc` as compilers, respectively. -Alternate compilers can be specified by passing `TOOLCHAIN=i686-whatever-` as a command line argument. +### Notes -You can build an executable with PAL or JPN ROM support by adding `ROMID=pal-final` or `ROMID=jpn-final` to the `make` command. -You will need to provide a `jpn-final` or `pal-final` ROM to run those, named `pd.jpn-final.z64` or `pd.pal-final.z64`. +Alternate compilers can be specified by passing `TOOLCHAIN=arch-whatever-` as a command line argument. -It might be possible to build a 32-bit ARM executable, but this has not been tested. +You will need to provide a `jpn-final` or `pal-final` ROM to run executables built for those regions, named `pd.jpn-final.z64` or `pd.pal-final.z64`. + +It might be possible to build and run the game on an ARM/AArch64 platform, but this has not been tested. ## Credits * the original [decompilation project](https://github.com/n64decomp/perfect_dark) authors; +* Ryan Dwyer for the above, additional help, and `pd-extract`; * doomhack for the only other publicly available [PD porting effort](https://github.com/doomhack/perfect_dark) I could find; * [sm64-port](https://github.com/sm64-port/sm64-port) authors for the audio mixer and some other changes; * [Ship of Harkinian team](https://github.com/Kenix3/libultraship/tree/main/src/graphic/Fast3D), Emill and MaikelChan for the libultraship version of fast3d that this port uses; * lieff for [minimp3](https://github.com/lieff/minimp3); * Mouse Injector and 1964GEPD authors for some of the 60FPS- and mouselook-related fixes; +* Raf for the 64-bit port; * NicNamSam for the icon; * everyone who has submitted pull requests and issues to this repository and tested the port; * probably more I'm forgetting.