From 167a4a5d81c2457aee709858da01e0ddb0ece118 Mon Sep 17 00:00:00 2001 From: Raf <> Date: Fri, 2 Aug 2024 16:48:35 +0800 Subject: [PATCH] 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;