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

1459 lines
39 KiB
C
Raw Blame History

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <PR/ultratypes.h>
#include <PR/gbi.h>
#include <PR/libaudio.h>
#include "platform.h"
#include "data.h"
#include "bss.h"
#include "preprocess.h"
#include "romdata.h"
#include "game/setuputils.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 + (u32)x)
#define PD_PTR_BASEOFS(x, b, d) (void *)((u8 *)b - d + (u32)x)
// 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 & 3));
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);
}
}
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 void 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);
}
}
static void 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);
}
}
static void preprocessModelNode(struct modelnode *node, u8 *base, u32 ofs)
{
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);
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:
preprocessModelGunDL(&ro->gundl, base, ofs);
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.vertices);
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);
}
break;
case MODELNODETYPE_HEADSPOT:
PD_SWAP_VAL(ro->headspot.rwdataindex);
break;
case MODELNODETYPE_DL:
preprocessModelDL(&ro->dl, base, ofs);
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:
fprintf(stderr, "preprocessModelNode: node at %p: unknown node->type: 0x%02x\n", 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;
}
}
}
}
}
static inline void preprocessPadData(u8 *ptr)
{
// 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) {
// 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 {
// 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))) {
// 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))) {
// 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) {
// 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:
fprintf(stderr, "unknown objtype: %02x @ %p\n", obj->type, obj);
fflush(stderr);
__builtin_trap();
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]);
}
void preprocessAnimations(u8 *data, u32 size)
{
// set the anim table pointers as well
extern u8 *_animationsTableRomStart;
extern u8 *_animationsTableRomEnd;
// the animation table is at the end of the segment
u32 *animtbl = (void *)(data + size - 0x38a0);
_animationsTableRomStart = (u8 *)animtbl;
_animationsTableRomEnd = data + size;
PD_SWAP_VAL(*animtbl);
const u32 count = *animtbl++;
struct animtableentry *anim = (struct animtableentry *)animtbl;
for (u32 i = 0; i < count; ++i, ++anim) {
PD_SWAP_VAL(anim->numframes);
PD_SWAP_VAL(anim->bytesperframe);
PD_SWAP_VAL(anim->headerlen);
PD_SWAP_VAL(anim->data);
}
}
void preprocessMpConfigs(u8 *data, u32 size)
{
const u32 count = size / sizeof(struct mpconfig);
struct mpconfig *cfg = (struct mpconfig *)data;
for (u32 i = 0; i < count; ++i, ++cfg) {
PD_SWAP_VAL(cfg->setup.options);
PD_SWAP_VAL(cfg->setup.teamscorelimit);
PD_SWAP_VAL(cfg->setup.chrslots);
// TODO: are these required or are they always 0?
PD_SWAP_VAL(cfg->setup.fileguid.deviceserial);
PD_SWAP_VAL(cfg->setup.fileguid.fileid);
}
}
void preprocessFont(u8 *data, u32 size)
{
struct font *fnt = (struct font *)data;
for (s32 i = 0; i < ARRAYCOUNT(fnt->kerning); ++i) {
PD_SWAP_VAL(fnt->kerning[i]);
}
for (s32 i = 0; i < ARRAYCOUNT(fnt->chars); ++i) {
PD_SWAP_VAL(fnt->chars[i].kerningindex);
PD_SWAP_PTR(fnt->chars[i].pixeldata);
}
}
void preprocessJpnFont(u8 *data, u32 size)
{
// ???
}
void preprocessALBankFile(u8 *data, u32 size)
{
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);
}
}
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]);
}
}
void preprocessSequences(u8 *data, u32 size)
{
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);
}
}
void preprocessTexturesList(u8 *data, u32 size)
{
struct texture *tex = (struct texture *)data;
const u32 count = size / sizeof(*tex);
for (u32 i = 0; i < count; ++i, ++tex) {
// TODO: it sure looks like none of the fields except soundsurfacetype, surfacetype and dataoffset are set
// just swap the last 3 bytes of the first word
const u32 dofs = (u32)tex->dataoffset << 8;
tex->dataoffset = PD_BE32(dofs);
}
}
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]);
}
}
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 (mdl->rootnode) {
PD_SWAP_PTR(mdl->rootnode);
preprocessModelNode(PD_PTR_BASEOFS(mdl->rootnode, base, ofs), base, ofs);
}
}
void preprocessLangFile(u8 *data, u32 size)
{
// 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
}
void preprocessPadsFile(u8 *data, u32 size)
{
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]);
preprocessPadData(PD_PTR_BASE(hdr->padoffsets[i], hdr));
}
}
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;
}
}
}
void preprocessTilesFile(u8 *data, u32 size)
{
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;
}
}
}
void preprocessSetupFile(u8 *data, u32 size)
{
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
}
void preprocessModelFile(u8 *data, u32 size)
{
preprocessModel(data, 0x5000000);
}
void preprocessGunFile(u8 *data, u32 size)
{
preprocessModel(data, 0x5000000);
}
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 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;
}
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);
}
uintptr_t pvoffset = sizeof(portals[0]) * (numportals + 1);
for (s32 i = 0; i < numportals; 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
}
}
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 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 = 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;
}
}
}
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);
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink