Merge branch 'main' into main
This commit is contained in:
CreateSource
GitHub
commit
83df5dfe18
110 changed files with 11426 additions and 1767 deletions
174
src/game/ClusterExec.c
Normal file
174
src/game/ClusterExec.c
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
#include "game/ClusterExec.h"
|
||||
#include "game/EnvelopeExec.h"
|
||||
#include "game/hsfmotion.h"
|
||||
|
||||
float GetClusterCurve(HsfTrack *arg0, float arg1) {
|
||||
float *var_r30;
|
||||
|
||||
switch (arg0->curveType) {
|
||||
case 1:
|
||||
return GetLinear(arg0->numKeyframes, arg0->data, arg1);
|
||||
case 2:
|
||||
return GetBezier(arg0->numKeyframes, arg0, arg1);
|
||||
case 4:
|
||||
var_r30 = &arg0->value;
|
||||
return *var_r30;
|
||||
}
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
float GetClusterWeightCurve(HsfTrack *arg0, float arg1) {
|
||||
float *var_r30;
|
||||
|
||||
switch (arg0->curveType) {
|
||||
case 1:
|
||||
return GetLinear(arg0->numKeyframes, arg0->data, arg1);
|
||||
case 2:
|
||||
return GetBezier(arg0->numKeyframes, arg0, arg1);
|
||||
case 4:
|
||||
var_r30 = &arg0->value;
|
||||
return *var_r30;
|
||||
}
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
void SetClusterMain(HsfCluster *arg0) {
|
||||
float var_f30;
|
||||
float var_f31;
|
||||
s32 temp_r24;
|
||||
s32 temp_r29;
|
||||
u16 *var_r28;
|
||||
s32 var_r23;
|
||||
s32 i;
|
||||
s32 j;
|
||||
HsfBuffer *temp_r25;
|
||||
HsfPart *temp_r27;
|
||||
HsfBuffer *temp_r30;
|
||||
|
||||
temp_r27 = arg0->part;
|
||||
if (arg0->vertexCnt != 0) {
|
||||
if (arg0->type == 2) {
|
||||
var_r28 = temp_r27->vertex;
|
||||
temp_r30 = *arg0->vertex;
|
||||
var_f30 = 0.0f;
|
||||
for (i = 0; i < arg0->vertexCnt; i++) {
|
||||
var_f30 += arg0->unk14[i];
|
||||
}
|
||||
for (i = 0; i < temp_r27->count; i++, var_r28++) {
|
||||
temp_r29 = *var_r28;
|
||||
Vertextop[temp_r29].x = ((Vec*) temp_r30->data)[i].x;
|
||||
Vertextop[temp_r29].y = ((Vec*) temp_r30->data)[i].y;
|
||||
Vertextop[temp_r29].z = ((Vec*) temp_r30->data)[i].z;
|
||||
}
|
||||
for (i = 1; i < arg0->vertexCnt; i++) {
|
||||
temp_r30 = arg0->vertex[i];
|
||||
var_r28 = temp_r27->vertex;
|
||||
var_f31 = arg0->unk14[i];
|
||||
if (var_f31 < 0.0f) {
|
||||
var_f31 = 0.0f;
|
||||
} else if (var_f30 > 1.0f) {
|
||||
var_f31 /= var_f30;
|
||||
}
|
||||
for (j = 0; j < temp_r27->count; j++, var_r28++) {
|
||||
temp_r29 = *var_r28;
|
||||
Vertextop[temp_r29].x += var_f31 * (((Vec*) temp_r30->data)[j].x - Vertextop[temp_r29].x);
|
||||
Vertextop[temp_r29].y += var_f31 * (((Vec*) temp_r30->data)[j].y - Vertextop[temp_r29].y);
|
||||
Vertextop[temp_r29].z += var_f31 * (((Vec*) temp_r30->data)[j].z - Vertextop[temp_r29].z);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
temp_r24 = arg0->unk10;
|
||||
var_r23 = temp_r24 + 1;
|
||||
if (var_r23 >= arg0->vertexCnt) {
|
||||
var_r23 = temp_r24;
|
||||
}
|
||||
var_f31 = arg0->unk10 - temp_r24;
|
||||
temp_r30 = arg0->vertex[temp_r24];
|
||||
temp_r25 = arg0->vertex[var_r23];
|
||||
var_r28 = temp_r27->vertex;
|
||||
for (i = 0; i < temp_r27->count; i++, var_r28++) {
|
||||
temp_r29 = *var_r28;
|
||||
Vertextop[temp_r29].x = ((Vec*) temp_r30->data)[i].x + var_f31 * (((Vec*) temp_r25->data)[i].x - ((Vec*) temp_r30->data)[i].x);
|
||||
Vertextop[temp_r29].y = ((Vec*) temp_r30->data)[i].y + var_f31 * (((Vec*) temp_r25->data)[i].y - ((Vec*) temp_r30->data)[i].y);
|
||||
Vertextop[temp_r29].z = ((Vec*) temp_r30->data)[i].z + var_f31 * (((Vec*) temp_r25->data)[i].z - ((Vec*) temp_r30->data)[i].z);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ClusterProc(ModelData *arg0) {
|
||||
s32 temp_r24;
|
||||
s32 i;
|
||||
s32 j;
|
||||
s32 k;
|
||||
HsfData *temp_r27;
|
||||
HsfData *temp_r23;
|
||||
MotionData *temp_r22;
|
||||
HsfCluster *var_r29;
|
||||
HsfObject *temp_r31;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
temp_r24 = arg0->unk_10[i];
|
||||
if (temp_r24 != -1) {
|
||||
temp_r22 = &Hu3DMotion[temp_r24];
|
||||
temp_r27 = temp_r22->unk_04;
|
||||
temp_r23 = arg0->hsfData;
|
||||
var_r29 = temp_r27->cluster;
|
||||
for (j = 0; j < temp_r27->clusterCnt; j++, var_r29++) {
|
||||
if (var_r29->target != -1) {
|
||||
temp_r31 = temp_r23->object;
|
||||
temp_r31 += var_r29->target;
|
||||
Vertextop = temp_r31->data.vertex->data;
|
||||
if (temp_r31->data.hook) {
|
||||
for (k = 0; k < temp_r31->data.vertex->count; k++) {
|
||||
Vertextop[k].x = ((Vec*) temp_r31->data.file[0])[k].x;
|
||||
Vertextop[k].y = ((Vec*) temp_r31->data.file[0])[k].y;
|
||||
Vertextop[k].z = ((Vec*) temp_r31->data.file[0])[k].z;
|
||||
}
|
||||
}
|
||||
SetClusterMain(var_r29);
|
||||
DCStoreRangeNoSync(Vertextop, temp_r31->data.vertex->count * sizeof(Vec));
|
||||
temp_r31->data.unk120[0]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ClusterMotionExec(ModelData *arg0) {
|
||||
float temp_f31;
|
||||
s32 i;
|
||||
s32 j;
|
||||
s16 var_r20;
|
||||
HsfCluster *temp_r26;
|
||||
HsfData *temp_r28;
|
||||
HsfMotion *temp_r27;
|
||||
HsfTrack *var_r31;
|
||||
HsfTrack *var_r30;
|
||||
MotionData *var_r23;
|
||||
|
||||
var_r31 = temp_r27->track;
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (arg0->unk_10[i] != -1) {
|
||||
var_r20 = arg0->unk_10[i];
|
||||
var_r23 = &Hu3DMotion[var_r20];
|
||||
temp_r28 = var_r23->unk_04;
|
||||
temp_r27 = temp_r28->motion;
|
||||
var_r31 = temp_r27->track;
|
||||
temp_f31 = arg0->unk_A4[i];
|
||||
for (j = 0; j < temp_r27->numTracks; j++, var_r31++) {
|
||||
switch (var_r31->type) {
|
||||
case 5:
|
||||
temp_r26 = &temp_r28->cluster[var_r31->target_s16];
|
||||
temp_r26->unk10 = GetClusterCurve(var_r31, temp_f31);
|
||||
break;
|
||||
case 6:
|
||||
var_r30 = var_r31;
|
||||
temp_r26 = &temp_r28->cluster[var_r30->target_s16];
|
||||
temp_r26->unk14[var_r30->unk04] = GetClusterCurve(var_r30, temp_f31);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
463
src/game/EnvelopeExec.c
Normal file
463
src/game/EnvelopeExec.c
Normal file
|
|
@ -0,0 +1,463 @@
|
|||
#include "game/EnvelopeExec.h"
|
||||
#include "game/hsfex.h"
|
||||
|
||||
#include "string.h"
|
||||
|
||||
static void SetEnvelopMtx(HsfObject *arg0, HsfObject *arg1, Mtx arg2);
|
||||
static void SetEnvelopMain(HsfData *arg0);
|
||||
static void SetEnvelop(HsfCenv *arg0);
|
||||
static void SetMtx(HsfObject *arg0, Mtx arg1);
|
||||
static void SetRevMtx(void);
|
||||
static HsfSkeleton *SearchSklenton(char *arg0);
|
||||
|
||||
Vec *Vertextop;
|
||||
Mtx *MtxTop;
|
||||
static u32 nObj;
|
||||
static u32 nMesh;
|
||||
static HsfObject *objtop;
|
||||
static HsfData *CurHsf;
|
||||
static Vec *vtxenv;
|
||||
static Vec *normenv;
|
||||
static Vec *normtop;
|
||||
static s32 Meshcnt;
|
||||
static s32 Meshno;
|
||||
|
||||
void InitEnvelope(HsfData *arg0) {
|
||||
HsfBuffer *spC;
|
||||
HsfBuffer *sp8;
|
||||
HsfMatrix *temp_r28;
|
||||
HsfObject *var_r31;
|
||||
HsfSkeleton *var_r30;
|
||||
Mtx sp10;
|
||||
s32 i;
|
||||
s32 j;
|
||||
|
||||
if (arg0->cenvCnt != 0) {
|
||||
var_r31 = arg0->object;
|
||||
for (Meshcnt = i = 0; i < arg0->objectCnt; i++, var_r31++) {
|
||||
if (var_r31->type == 2) {
|
||||
if (var_r31->data.file[0]) {
|
||||
spC = var_r31->data.vertex;
|
||||
sp8 = var_r31->data.normal;
|
||||
Meshcnt++;
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
var_r30 = arg0->skeleton;
|
||||
for (j = 0; j < arg0->skeletonCnt; j++, var_r30++) {
|
||||
if (strcmp(var_r31->name, var_r30->name) == 0) {
|
||||
var_r31->data.base.pos.x = var_r30->transform.pos.x;
|
||||
var_r31->data.base.pos.y = var_r30->transform.pos.y;
|
||||
var_r31->data.base.pos.z = var_r30->transform.pos.z;
|
||||
var_r31->data.base.rot.x = var_r30->transform.rot.x;
|
||||
var_r31->data.base.rot.y = var_r30->transform.rot.y;
|
||||
var_r31->data.base.rot.z = var_r30->transform.rot.z;
|
||||
var_r31->data.base.scale.x = var_r30->transform.scale.x;
|
||||
var_r31->data.base.scale.y = var_r30->transform.scale.y;
|
||||
var_r31->data.base.scale.z = var_r30->transform.scale.z;
|
||||
}
|
||||
}
|
||||
var_r31->data.curr.pos.x = var_r31->data.base.pos.x;
|
||||
var_r31->data.curr.pos.y = var_r31->data.base.pos.y;
|
||||
var_r31->data.curr.pos.z = var_r31->data.base.pos.z;
|
||||
var_r31->data.curr.rot.x = var_r31->data.base.rot.x;
|
||||
var_r31->data.curr.rot.y = var_r31->data.base.rot.y;
|
||||
var_r31->data.curr.rot.z = var_r31->data.base.rot.z;
|
||||
var_r31->data.curr.scale.x = var_r31->data.base.scale.x;
|
||||
var_r31->data.curr.scale.y = var_r31->data.base.scale.y;
|
||||
var_r31->data.curr.scale.z = var_r31->data.base.scale.z;
|
||||
}
|
||||
CurHsf = arg0;
|
||||
objtop = arg0->object;
|
||||
temp_r28 = CurHsf->matrix;
|
||||
if (temp_r28) {
|
||||
MtxTop = temp_r28->data;
|
||||
nObj = temp_r28->count;
|
||||
nMesh = temp_r28->base_idx;
|
||||
}
|
||||
PSMTXIdentity(sp10);
|
||||
SetMtx(arg0->root, sp10);
|
||||
SetRevMtx();
|
||||
}
|
||||
}
|
||||
|
||||
static void SetEnvelopMtx(HsfObject *arg0, HsfObject *arg1, Mtx arg2) {
|
||||
Mtx sp6C;
|
||||
Mtx sp3C;
|
||||
Mtx spC;
|
||||
s32 var_r29;
|
||||
s32 i;
|
||||
|
||||
PSMTXTrans(spC, arg1->data.curr.pos.x, arg1->data.curr.pos.y, arg1->data.curr.pos.z);
|
||||
PSMTXConcat(arg2, spC, sp3C);
|
||||
if (arg1->data.curr.rot.z) {
|
||||
PSMTXRotRad(sp6C, 'z', MTXDegToRad(arg1->data.curr.rot.z));
|
||||
PSMTXConcat(sp3C, sp6C, sp3C);
|
||||
}
|
||||
if (arg1->data.curr.rot.y) {
|
||||
PSMTXRotRad(sp6C, 'y', MTXDegToRad(arg1->data.curr.rot.y));
|
||||
PSMTXConcat(sp3C, sp6C, sp3C);
|
||||
}
|
||||
if (arg1->data.curr.rot.x) {
|
||||
PSMTXRotRad(sp6C, 'x', MTXDegToRad(arg1->data.curr.rot.x));
|
||||
PSMTXConcat(sp3C, sp6C, sp3C);
|
||||
}
|
||||
if (arg1->data.curr.scale.x != 1.0f) {
|
||||
sp3C[0][0] *= arg1->data.curr.scale.x;
|
||||
sp3C[1][0] *= arg1->data.curr.scale.x;
|
||||
sp3C[2][0] *= arg1->data.curr.scale.x;
|
||||
}
|
||||
if (arg1->data.curr.scale.y != 1.0f) {
|
||||
sp3C[0][1] *= arg1->data.curr.scale.y;
|
||||
sp3C[1][1] *= arg1->data.curr.scale.y;
|
||||
sp3C[2][1] *= arg1->data.curr.scale.y;
|
||||
}
|
||||
if (arg1->data.curr.scale.z != 1.0f) {
|
||||
sp3C[0][2] *= arg1->data.curr.scale.z;
|
||||
sp3C[1][2] *= arg1->data.curr.scale.z;
|
||||
sp3C[2][2] *= arg1->data.curr.scale.z;
|
||||
}
|
||||
var_r29 = arg1 - arg0;
|
||||
PSMTXCopy(sp3C, MtxTop[nMesh + var_r29]);
|
||||
for (i = 0; i < arg1->data.childrenCount; i++) {
|
||||
SetEnvelopMtx(arg0, arg1->data.children[i], sp3C);
|
||||
}
|
||||
}
|
||||
|
||||
void EnvelopeProc(HsfData *arg0) {
|
||||
HsfMatrix *temp_r31;
|
||||
HsfObject *temp_r29;
|
||||
Mtx sp8;
|
||||
|
||||
CurHsf = arg0;
|
||||
temp_r31 = CurHsf->matrix;
|
||||
MtxTop = temp_r31->data;
|
||||
nObj = temp_r31->count;
|
||||
nMesh = temp_r31->base_idx;
|
||||
temp_r29 = arg0->root;
|
||||
PSMTXIdentity(sp8);
|
||||
SetEnvelopMtx(arg0->object, temp_r29, sp8);
|
||||
SetEnvelopMain(arg0);
|
||||
}
|
||||
|
||||
void InitVtxParm(HsfData *arg0) {
|
||||
HsfObject *var_r31;
|
||||
s32 i;
|
||||
|
||||
var_r31 = arg0->object;
|
||||
for (i = 0; i < arg0->objectCnt; i++, var_r31++) {
|
||||
if (var_r31->type == 2) {
|
||||
var_r31->data.unk120[0] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void SetEnvelopMain(HsfData *arg0) {
|
||||
void *sp10;
|
||||
void *spC;
|
||||
void *sp8;
|
||||
HsfBuffer *temp_r28;
|
||||
HsfBuffer *temp_r30;
|
||||
HsfObject *var_r31;
|
||||
s32 i;
|
||||
s32 j;
|
||||
HsfCenv *var_r25;
|
||||
|
||||
var_r31 = arg0->object;
|
||||
for (Meshno = i = 0; i < arg0->objectCnt; i++, var_r31++) {
|
||||
if (var_r31->type == 2) {
|
||||
PSMTXInverse(MtxTop[&var_r31[nMesh] - arg0->object], MtxTop[Meshno]);
|
||||
temp_r30 = var_r31->data.vertex;
|
||||
temp_r28 = var_r31->data.normal;
|
||||
if (var_r31->data.unk120[0] != 0) {
|
||||
Vertextop = temp_r30->data;
|
||||
} else {
|
||||
Vertextop = var_r31->data.file[0];
|
||||
}
|
||||
vtxenv = temp_r30->data;
|
||||
normtop = var_r31->data.file[1];
|
||||
normenv = temp_r28->data;
|
||||
var_r25 = var_r31->data.cenv;
|
||||
for (j = 0; j < var_r31->data.hook; j++, var_r25++) {
|
||||
SetEnvelop(var_r25);
|
||||
}
|
||||
sp10 = temp_r30->data;
|
||||
spC = var_r31->data.file[0];
|
||||
sp8 = temp_r30->data;
|
||||
DCStoreRangeNoSync(normenv, temp_r28->count * sizeof(Vec));
|
||||
DCStoreRangeNoSync(vtxenv, temp_r30->count * sizeof(Vec));
|
||||
Meshno++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void SetEnvelop(HsfCenv *arg0) {
|
||||
Vec sp44;
|
||||
Vec sp38;
|
||||
Vec sp2C;
|
||||
Vec sp20;
|
||||
Vec sp14;
|
||||
s32 sp10;
|
||||
u32 spC;
|
||||
u32 sp8;
|
||||
HsfCenvDual *var_r20;
|
||||
HsfCenvDualWeight *var_r30;
|
||||
HsfCenvMulti *var_r19;
|
||||
HsfCenvMultiWeight *var_r25;
|
||||
HsfCenvSingle *var_r27;
|
||||
Vec *temp_r22;
|
||||
Vec *temp_r26;
|
||||
Vec *temp_r28;
|
||||
Vec *temp_r31;
|
||||
float temp_f31;
|
||||
MtxPtr var_r29;
|
||||
s32 temp_r18;
|
||||
s32 temp_r21;
|
||||
s32 i;
|
||||
s32 j;
|
||||
Mtx sp1A0;
|
||||
Mtx sp170;
|
||||
Mtx sp140;
|
||||
Mtx sp110;
|
||||
Mtx spE0;
|
||||
Mtx spB0;
|
||||
Mtx sp80;
|
||||
Mtx sp50;
|
||||
|
||||
var_r27 = arg0->singleData;
|
||||
for (i = 0; i < arg0->singleCount; i++, var_r27++) {
|
||||
temp_r18 = var_r27->normal;
|
||||
temp_r21 = var_r27->pos;
|
||||
temp_r28 = &vtxenv[temp_r21];
|
||||
temp_r31 = &Vertextop[temp_r21];
|
||||
temp_r22 = &normenv[temp_r18];
|
||||
temp_r26 = &normtop[temp_r18];
|
||||
PSMTXConcat(MtxTop[nMesh + var_r27->target], MtxTop[nMesh + nObj + nObj * Meshno + var_r27->target], sp140);
|
||||
PSMTXConcat(MtxTop[Meshno], sp140, sp1A0);
|
||||
Hu3DMtxScaleGet(&sp1A0[0], &sp14);
|
||||
if (sp14.x != 1.0f || sp14.y != 1.0f || sp14.z != 1.0f) {
|
||||
PSMTXScale(spE0, 1.0 / sp14.x, 1.0 / sp14.y, 1.0 / sp14.z);
|
||||
PSMTXConcat(spE0, sp1A0, sp170);
|
||||
PSMTXInvXpose(sp170, sp170);
|
||||
} else {
|
||||
PSMTXInvXpose(sp1A0, sp170);
|
||||
}
|
||||
if (var_r27->posCnt == 1) {
|
||||
PSMTXMultVec(sp1A0, temp_r31, temp_r28);
|
||||
PSMTXMultVec(sp170, temp_r26, temp_r22);
|
||||
} else if (var_r27->posCnt <= 6) {
|
||||
PSMTXMultVecArray(sp1A0, temp_r31, temp_r28, var_r27->posCnt);
|
||||
PSMTXMultVecArray(sp170, temp_r26, temp_r22, var_r27->normalCnt);
|
||||
} else {
|
||||
PSMTXReorder(sp1A0, (ROMtxPtr) sp140);
|
||||
PSMTXReorder(sp170, (ROMtxPtr) sp110);
|
||||
PSMTXROMultVecArray((ROMtxPtr) sp140, temp_r31, temp_r28, var_r27->posCnt);
|
||||
PSMTXROMultVecArray((ROMtxPtr) sp110, temp_r26, temp_r22, var_r27->normalCnt);
|
||||
}
|
||||
}
|
||||
var_r20 = arg0->dualData;
|
||||
for (i = 0; i < arg0->dualCount; i++, var_r20++) {
|
||||
spC = var_r20->target1;
|
||||
sp8 = var_r20->target2;
|
||||
PSMTXConcat(MtxTop[nMesh + spC], MtxTop[nMesh + nObj + nObj * Meshno + spC], sp140);
|
||||
PSMTXConcat(MtxTop[Meshno], sp140, sp1A0);
|
||||
PSMTXConcat(MtxTop[nMesh + sp8], MtxTop[nMesh + nObj + nObj * Meshno + sp8], sp140);
|
||||
PSMTXConcat(MtxTop[Meshno], sp140, (float (*)[4]) &spB0[0]);
|
||||
var_r30 = var_r20->weight;
|
||||
for (j = 0; j < var_r20->weightCnt; j++, var_r30++) {
|
||||
temp_r18 = var_r30->normal;
|
||||
temp_r21 = var_r30->pos;
|
||||
temp_r28 = &vtxenv[temp_r21];
|
||||
temp_r31 = &Vertextop[temp_r21];
|
||||
temp_r22 = &normenv[temp_r18];
|
||||
temp_r26 = &normtop[temp_r18];
|
||||
temp_f31 = var_r30->weight;
|
||||
sp140[0][0] = sp1A0[0][0] * temp_f31;
|
||||
sp140[1][0] = sp1A0[1][0] * temp_f31;
|
||||
sp140[2][0] = sp1A0[2][0] * temp_f31;
|
||||
sp140[0][1] = sp1A0[0][1] * temp_f31;
|
||||
sp140[1][1] = sp1A0[1][1] * temp_f31;
|
||||
sp140[2][1] = sp1A0[2][1] * temp_f31;
|
||||
sp140[0][2] = sp1A0[0][2] * temp_f31;
|
||||
sp140[1][2] = sp1A0[1][2] * temp_f31;
|
||||
sp140[2][2] = sp1A0[2][2] * temp_f31;
|
||||
sp140[0][3] = sp1A0[0][3] * temp_f31;
|
||||
sp140[1][3] = sp1A0[1][3] * temp_f31;
|
||||
sp140[2][3] = sp1A0[2][3] * temp_f31;
|
||||
temp_f31 = 1.0f - var_r30->weight;
|
||||
sp110[0][0] = spB0[0][0] * temp_f31;
|
||||
sp110[1][0] = spB0[1][0] * temp_f31;
|
||||
sp110[2][0] = spB0[2][0] * temp_f31;
|
||||
sp110[0][1] = spB0[0][1] * temp_f31;
|
||||
sp110[1][1] = spB0[1][1] * temp_f31;
|
||||
sp110[2][1] = spB0[2][1] * temp_f31;
|
||||
sp110[0][2] = spB0[0][2] * temp_f31;
|
||||
sp110[1][2] = spB0[1][2] * temp_f31;
|
||||
sp110[2][2] = spB0[2][2] * temp_f31;
|
||||
sp110[0][3] = spB0[0][3] * temp_f31;
|
||||
sp110[1][3] = spB0[1][3] * temp_f31;
|
||||
sp110[2][3] = spB0[2][3] * temp_f31;
|
||||
if (sp80 == sp110 || sp80 == sp140) {
|
||||
var_r29 = sp50;
|
||||
} else {
|
||||
var_r29 = sp80;
|
||||
}
|
||||
var_r29[0][0] = sp110[0][0] + sp140[0][0];
|
||||
var_r29[0][1] = sp110[0][1] + sp140[0][1];
|
||||
var_r29[0][2] = sp110[0][2] + sp140[0][2];
|
||||
var_r29[0][3] = sp110[0][3] + sp140[0][3];
|
||||
var_r29[1][0] = sp110[1][0] + sp140[1][0];
|
||||
var_r29[1][1] = sp110[1][1] + sp140[1][1];
|
||||
var_r29[1][2] = sp110[1][2] + sp140[1][2];
|
||||
var_r29[1][3] = sp110[1][3] + sp140[1][3];
|
||||
var_r29[2][0] = sp110[2][0] + sp140[2][0];
|
||||
var_r29[2][1] = sp110[2][1] + sp140[2][1];
|
||||
var_r29[2][2] = sp110[2][2] + sp140[2][2];
|
||||
var_r29[2][3] = sp110[2][3] + sp140[2][3];
|
||||
if (var_r29 == sp50) {
|
||||
PSMTXCopy(sp50, sp80);
|
||||
}
|
||||
Hu3DMtxScaleGet(&sp80[0], &sp14);
|
||||
if (sp14.x != 1.0f || sp14.y != 1.0f || sp14.z != 1.0f) {
|
||||
PSMTXScale(spE0, 1.0 / sp14.x, 1.0 / sp14.y, 1.0 / sp14.z);
|
||||
PSMTXConcat(spE0, sp80, sp110);
|
||||
PSMTXInvXpose(sp110, sp110);
|
||||
} else {
|
||||
PSMTXInvXpose(sp80, sp110);
|
||||
}
|
||||
if (var_r30->posCnt == 1) {
|
||||
PSMTXMultVec(sp80, temp_r31, temp_r28);
|
||||
} else if (var_r30->posCnt <= 6) {
|
||||
PSMTXMultVecArray(sp80, temp_r31, temp_r28, var_r30->posCnt);
|
||||
} else {
|
||||
PSMTXReorder(sp80, (ROMtxPtr) sp140);
|
||||
PSMTXROMultVecArray((ROMtxPtr) sp140, temp_r31, temp_r28, var_r30->posCnt);
|
||||
}
|
||||
if (var_r30->normalCnt != 0) {
|
||||
if (var_r30->normalCnt == 1) {
|
||||
PSMTXMultVec(sp110, temp_r26, temp_r22);
|
||||
} else if (var_r30->normalCnt <= 6) {
|
||||
PSMTXMultVecArray(sp110, temp_r26, temp_r22, var_r30->normalCnt);
|
||||
} else {
|
||||
PSMTXReorder(sp110, (ROMtxPtr) sp140);
|
||||
PSMTXROMultVecArray((ROMtxPtr) sp140, temp_r26, temp_r22, var_r30->normalCnt);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
var_r19 = arg0->multiData;
|
||||
for (i = 0; i < arg0->multiCount; i++, var_r19++) {
|
||||
var_r25 = var_r19->weight;
|
||||
temp_r18 = var_r19->normal;
|
||||
temp_r21 = var_r19->pos;
|
||||
temp_r28 = &vtxenv[temp_r21];
|
||||
temp_r31 = &Vertextop[temp_r21];
|
||||
temp_r22 = &normenv[temp_r18];
|
||||
temp_r26 = &normtop[temp_r18];
|
||||
sp38.x = sp38.y = sp38.z = 0.0f;
|
||||
sp20.x = sp20.y = sp20.z = 0.0f;
|
||||
sp10 = 0;
|
||||
for (j = 0; j < var_r19->weightCnt; j++, var_r25++) {
|
||||
PSMTXConcat(MtxTop[nMesh + var_r25->target], MtxTop[nMesh + nObj + nObj * Meshno + var_r25->target], sp1A0);
|
||||
PSMTXConcat(MtxTop[Meshno], sp1A0, sp1A0);
|
||||
PSMTXInvXpose(sp1A0, sp170);
|
||||
PSMTXMultVec(sp1A0, temp_r31, &sp44);
|
||||
PSMTXMultVec(sp170, temp_r26, &sp2C);
|
||||
sp44.x = var_r25->value * (sp44.x - temp_r31->x);
|
||||
sp44.y = var_r25->value * (sp44.y - temp_r31->y);
|
||||
sp44.z = var_r25->value * (sp44.z - temp_r31->z);
|
||||
PSVECAdd(&sp38, &sp44, &sp38);
|
||||
sp2C.x = var_r25->value * (sp2C.x - temp_r26->x);
|
||||
sp2C.y = var_r25->value * (sp2C.y - temp_r26->y);
|
||||
sp2C.z = var_r25->value * (sp2C.z - temp_r26->z);
|
||||
PSVECAdd(&sp20, &sp2C, &sp20);
|
||||
}
|
||||
temp_r28->x = temp_r31->x + sp38.x;
|
||||
temp_r28->y = temp_r31->y + sp38.y;
|
||||
temp_r28->z = temp_r31->z + sp38.z;
|
||||
temp_r22->x = temp_r26->x + sp20.x;
|
||||
temp_r22->y = temp_r26->y + sp20.y;
|
||||
temp_r22->z = temp_r26->z + sp20.z;
|
||||
}
|
||||
temp_r21 = arg0->vtxCount;
|
||||
temp_r28 = &vtxenv[temp_r21];
|
||||
temp_r31 = &Vertextop[temp_r21];
|
||||
for (i = 0; i < arg0->copyCount; i++, temp_r28++, temp_r31++) {
|
||||
temp_r28->x = temp_r31->x;
|
||||
temp_r28->y = temp_r31->y;
|
||||
temp_r28->z = temp_r31->z;
|
||||
}
|
||||
}
|
||||
|
||||
static void SetMtx(HsfObject *arg0, Mtx arg1) {
|
||||
HsfSkeleton *temp_r3;
|
||||
Mtx spFC;
|
||||
Mtx spCC;
|
||||
Mtx sp9C;
|
||||
s32 temp_r25;
|
||||
s32 i;
|
||||
|
||||
temp_r3 = SearchSklenton(arg0->name);
|
||||
if (temp_r3) {
|
||||
arg0->data.base.pos.x = temp_r3->transform.pos.x;
|
||||
arg0->data.base.pos.y = temp_r3->transform.pos.y;
|
||||
arg0->data.base.pos.z = temp_r3->transform.pos.z;
|
||||
arg0->data.base.rot.x = temp_r3->transform.rot.x;
|
||||
arg0->data.base.rot.y = temp_r3->transform.rot.y;
|
||||
arg0->data.base.rot.z = temp_r3->transform.rot.z;
|
||||
arg0->data.base.scale.x = temp_r3->transform.scale.x;
|
||||
arg0->data.base.scale.y = temp_r3->transform.scale.y;
|
||||
arg0->data.base.scale.z = temp_r3->transform.scale.z;
|
||||
}
|
||||
PSMTXTrans(spFC, arg0->data.base.pos.x, arg0->data.base.pos.y, arg0->data.base.pos.z);
|
||||
PSMTXScale(spCC, arg0->data.base.scale.x, arg0->data.base.scale.y, arg0->data.base.scale.z);
|
||||
PSMTXConcat(arg1, spFC, spFC);
|
||||
PSMTXRotRad(sp9C, 'z', MTXDegToRad(arg0->data.base.rot.z));
|
||||
PSMTXConcat(spFC, sp9C, spFC);
|
||||
PSMTXRotRad(sp9C, 'y', MTXDegToRad(arg0->data.base.rot.y));
|
||||
PSMTXConcat(spFC, sp9C, spFC);
|
||||
PSMTXRotRad(sp9C, 'x', MTXDegToRad(arg0->data.base.rot.x));
|
||||
PSMTXConcat(spFC, sp9C, spFC);
|
||||
PSMTXConcat(spFC, spCC, spFC);
|
||||
temp_r25 = arg0 - objtop;
|
||||
PSMTXCopy(spFC, MtxTop[nMesh + temp_r25]);
|
||||
for (i = 0; i < arg0->data.childrenCount; i++) {
|
||||
SetMtx(arg0->data.children[i], spFC);
|
||||
}
|
||||
}
|
||||
|
||||
static void SetRevMtx(void) {
|
||||
HsfObject *var_r29;
|
||||
s32 var_r28;
|
||||
s32 i;
|
||||
s32 var_r30;
|
||||
Mtx sp38;
|
||||
Mtx sp8;
|
||||
|
||||
var_r29 = CurHsf->object;
|
||||
for (var_r28 = i = 0; i < CurHsf->objectCnt; i++, var_r29++) {
|
||||
if (var_r29->type == 2) {
|
||||
PSMTXCopy(MtxTop[nMesh + i], sp8);
|
||||
for (var_r30 = 0; var_r30 < CurHsf->objectCnt; var_r30++) {
|
||||
PSMTXInverse(MtxTop[nMesh + var_r30], sp38);
|
||||
PSMTXConcat(sp38, sp8, MtxTop[nMesh + nObj + nObj * var_r28 + var_r30]);
|
||||
}
|
||||
PSMTXInverse(MtxTop[nMesh + i], sp8);
|
||||
var_r28++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static HsfSkeleton *SearchSklenton(char *arg0) {
|
||||
HsfSkeleton *var_r31;
|
||||
s32 i;
|
||||
|
||||
var_r31 = CurHsf->skeleton;
|
||||
for (i = 0; i < CurHsf->skeletonCnt; i++, var_r31++) {
|
||||
if (strcmp(arg0, var_r31->name) == 0) {
|
||||
return var_r31;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
69
src/game/ShapeExec.c
Executable file
69
src/game/ShapeExec.c
Executable file
|
|
@ -0,0 +1,69 @@
|
|||
#include "game/ShapeExec.h"
|
||||
#include "game/EnvelopeExec.h"
|
||||
|
||||
static void SetShapeMain(HsfObject *arg0) {
|
||||
HsfBuffer *temp_r28;
|
||||
HsfBuffer *temp_r30;
|
||||
float var_f30;
|
||||
float var_f31;
|
||||
s32 temp_r27;
|
||||
s32 var_r29;
|
||||
s32 var_r26;
|
||||
s32 i;
|
||||
|
||||
if (arg0->data.shapeType == 2) {
|
||||
var_f30 = 0.0f;
|
||||
for (i = 0; i < arg0->data.vertexShapeCnt; i++) {
|
||||
var_f30 += arg0->data.mesh.morphWeight[i];
|
||||
}
|
||||
temp_r30 = *arg0->data.vertexShape;
|
||||
for (i = 0; i < temp_r30->count; i++) {
|
||||
Vertextop[i].x = ((Vec*) temp_r30->data)[i].x;
|
||||
Vertextop[i].y = ((Vec*) temp_r30->data)[i].y;
|
||||
Vertextop[i].z = ((Vec*) temp_r30->data)[i].z;
|
||||
}
|
||||
for (i = 0; i < arg0->data.vertexShapeCnt; i++) {
|
||||
temp_r30 = arg0->data.vertexShape[i];
|
||||
var_f31 = arg0->data.mesh.morphWeight[i];
|
||||
if (var_f31 < 0.0f) {
|
||||
var_f31 = 0.0f;
|
||||
} else if (var_f30 > 1.0f) {
|
||||
var_f31 /= var_f30;
|
||||
}
|
||||
for (var_r29 = 0; var_r29 < temp_r30->count; var_r29++) {
|
||||
Vertextop[var_r29].x += var_f31 * (((Vec*) temp_r30->data)[var_r29].x - Vertextop[var_r29].x);
|
||||
Vertextop[var_r29].y += var_f31 * (((Vec*) temp_r30->data)[var_r29].y - Vertextop[var_r29].y);
|
||||
Vertextop[var_r29].z += var_f31 * (((Vec*) temp_r30->data)[var_r29].z - Vertextop[var_r29].z);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
temp_r27 = arg0->data.mesh.baseMorph;
|
||||
var_r26 = temp_r27 + 1;
|
||||
if (var_r26 >= arg0->data.vertexShapeCnt) {
|
||||
var_r26 = temp_r27;
|
||||
}
|
||||
var_f31 = arg0->data.mesh.baseMorph - temp_r27;
|
||||
temp_r30 = arg0->data.vertexShape[temp_r27];
|
||||
temp_r28 = arg0->data.vertexShape[var_r26];
|
||||
for (i = 0; i < temp_r30->count; i++) {
|
||||
Vertextop[i].x = ((Vec*) temp_r30->data)[i].x + var_f31 * (((Vec*) temp_r28->data)[i].x - ((Vec*) temp_r30->data)[i].x);
|
||||
Vertextop[i].y = ((Vec*) temp_r30->data)[i].y + var_f31 * (((Vec*) temp_r28->data)[i].y - ((Vec*) temp_r30->data)[i].y);
|
||||
Vertextop[i].z = ((Vec*) temp_r30->data)[i].z + var_f31 * (((Vec*) temp_r28->data)[i].z - ((Vec*) temp_r30->data)[i].z);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ShapeProc(HsfData *arg0) {
|
||||
HsfObject *var_r31;
|
||||
s32 i;
|
||||
|
||||
var_r31 = arg0->object;
|
||||
for (i = 0; i < arg0->objectCnt; i++, var_r31++) {
|
||||
if (var_r31->type == 2 && var_r31->data.vertexShapeCnt != 0) {
|
||||
Vertextop = var_r31->data.vertex->data;
|
||||
SetShapeMain(var_r31);
|
||||
DCStoreRange(Vertextop, var_r31->data.vertex->count * sizeof(Vec));
|
||||
var_r31->data.unk120[0]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
109
src/game/THPDraw.c
Executable file
109
src/game/THPDraw.c
Executable file
|
|
@ -0,0 +1,109 @@
|
|||
#include "game/THPDraw.h"
|
||||
|
||||
void THPGXRestore(void) {
|
||||
GXSetZMode(GX_TRUE, GX_ALWAYS, GX_FALSE);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_ONE, GX_BL_ZERO, GX_LO_SET);
|
||||
GXSetNumTexGens(1);
|
||||
GXSetNumChans(0);
|
||||
GXSetNumTevStages(1);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_REPLACE);
|
||||
GXSetTevSwapMode(GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0);
|
||||
GXSetTevSwapMode(GX_TEVSTAGE1, GX_TEV_SWAP0, GX_TEV_SWAP0);
|
||||
GXSetTevSwapMode(GX_TEVSTAGE2, GX_TEV_SWAP0, GX_TEV_SWAP0);
|
||||
GXSetTevSwapMode(GX_TEVSTAGE3, GX_TEV_SWAP0, GX_TEV_SWAP0);
|
||||
GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
|
||||
GXSetTevSwapModeTable(GX_TEV_SWAP1, GX_CH_RED, GX_CH_RED, GX_CH_RED, GX_CH_ALPHA);
|
||||
GXSetTevSwapModeTable(GX_TEV_SWAP2, GX_CH_GREEN, GX_CH_GREEN, GX_CH_GREEN, GX_CH_ALPHA);
|
||||
GXSetTevSwapModeTable(GX_TEV_SWAP3, GX_CH_BLUE, GX_CH_BLUE, GX_CH_BLUE, GX_CH_ALPHA);
|
||||
GXSetTevKAlphaSel(GX_TEVSTAGE0, GX_TEV_KASEL_1);
|
||||
GXSetTevKAlphaSel(GX_TEVSTAGE1, GX_TEV_KASEL_1);
|
||||
}
|
||||
|
||||
void THPGXYuv2RgbSetup(GXRenderModeObj *obj, GXColor *arg1, Mtx arg2) {
|
||||
s32 sp2C = obj->fbWidth;
|
||||
s32 sp28 = obj->efbHeight;
|
||||
|
||||
GXLoadPosMtxImm(arg2, GX_PNMTX0);
|
||||
GXSetCurrentMtx(GX_PNMTX0);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
|
||||
GXSetColorUpdate(GX_TRUE);
|
||||
GXSetAlphaUpdate(GX_FALSE);
|
||||
GXSetNumChans(0);
|
||||
GXSetNumTexGens(2);
|
||||
GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY, GX_FALSE, GX_PTIDENTITY);
|
||||
GXSetTexCoordGen2(GX_TEXCOORD1, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY, GX_FALSE, GX_PTIDENTITY);
|
||||
GXInvalidateTexAll();
|
||||
GXClearVtxDesc();
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT7, GX_VA_POS, GX_TEX_ST, GX_RGBA4, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT7, GX_VA_TEX0, GX_TEX_ST, GX_RGBX8, 0);
|
||||
GXSetNumTevStages(5);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD1, GX_TEXMAP1, GX_COLOR_NULL);
|
||||
GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_TEXC, GX_CC_KONST, GX_CC_C0);
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_TEXA, GX_CA_KONST, GX_CA_A0);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_SUB, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetTevKColorSel(GX_TEVSTAGE0, GX_TEV_KCSEL_K0);
|
||||
GXSetTevKAlphaSel(GX_TEVSTAGE0, GX_TEV_KASEL_K0_A);
|
||||
GXSetTevSwapMode(GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0);
|
||||
GXSetTevOrder(GX_TEVSTAGE1, GX_TEXCOORD1, GX_TEXMAP2, GX_COLOR_NULL);
|
||||
GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_TEXC, GX_CC_KONST, GX_CC_CPREV);
|
||||
GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_2, GX_FALSE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_TEXA, GX_CA_KONST, GX_CA_APREV);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_SUB, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetTevKColorSel(GX_TEVSTAGE1, GX_TEV_KCSEL_K1);
|
||||
GXSetTevKAlphaSel(GX_TEVSTAGE1, GX_TEV_KASEL_K1_A);
|
||||
GXSetTevSwapMode(GX_TEVSTAGE1, GX_TEV_SWAP0, GX_TEV_SWAP0);
|
||||
GXSetTevOrder(GX_TEVSTAGE2, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
|
||||
GXSetTevColorIn(GX_TEVSTAGE2, GX_CC_ZERO, GX_CC_TEXC, GX_CC_ONE, GX_CC_CPREV);
|
||||
GXSetTevColorOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE2, GX_CA_TEXA, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevSwapMode(GX_TEVSTAGE2, GX_TEV_SWAP0, GX_TEV_SWAP0);
|
||||
GXSetTevOrder(GX_TEVSTAGE3, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR_NULL);
|
||||
GXSetTevColorIn(GX_TEVSTAGE3, GX_CC_APREV, GX_CC_CPREV, GX_CC_KONST, GX_CC_ZERO);
|
||||
GXSetTevColorOp(GX_TEVSTAGE3, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE3, GX_CA_KONST, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE3, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevSwapMode(GX_TEVSTAGE3, GX_TEV_SWAP0, GX_TEV_SWAP0);
|
||||
GXSetTevKColorSel(GX_TEVSTAGE3, GX_TEV_KCSEL_K2);
|
||||
GXSetTevColor(GX_TEVREG1, *arg1);
|
||||
GXSetTevOrder(GX_TEVSTAGE4, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR_NULL);
|
||||
GXSetTevColorIn(GX_TEVSTAGE4, GX_CC_ZERO, GX_CC_CPREV, GX_CC_C1, GX_CC_ZERO);
|
||||
GXSetTevColorOp(GX_TEVSTAGE4, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE4, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A1);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE4, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevColorS10(GX_TEVREG0, (GXColorS10) { 0xFFA6, 0, 0xFF8E, 0x0087 });
|
||||
GXSetTevKColor(GX_KCOLOR0, (GXColor) { 0, 0, 0xE2, 0x58 });
|
||||
GXSetTevKColor(GX_KCOLOR1, (GXColor) { 0xB3, 0, 0, 0xB6 });
|
||||
GXSetTevKColor(GX_KCOLOR2, (GXColor) { 0xFF, 0, 0xFF, 0x80 });
|
||||
GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
|
||||
}
|
||||
|
||||
void THPGXYuv2RgbDraw(u32 *yImage, u32 *uImage, u32 *vImage, s16 x, s16 y, s16 texWidth, s16 texHeight, s16 polyWidth, s16 polyHeight) {
|
||||
GXTexObj sp54;
|
||||
GXTexObj sp34;
|
||||
GXTexObj sp14;
|
||||
|
||||
GXInitTexObj(&sp54, yImage, texWidth, texHeight, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
|
||||
GXInitTexObjLOD(&sp54, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1);
|
||||
GXLoadTexObj(&sp54, GX_TEXMAP0);
|
||||
GXInitTexObj(&sp34, uImage, texWidth >> 1, texHeight >> 1, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
|
||||
GXInitTexObjLOD(&sp34, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1);
|
||||
GXLoadTexObj(&sp34, GX_TEXMAP1);
|
||||
GXInitTexObj(&sp14, vImage, texWidth >> 1, texHeight >> 1, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
|
||||
GXInitTexObjLOD(&sp14, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1);
|
||||
GXLoadTexObj(&sp14, GX_TEXMAP2);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT7, 4);
|
||||
GXPosition3s16(x, y, 0);
|
||||
GXTexCoord2s16(0, 0);
|
||||
GXPosition3s16(x + polyWidth, y, 0);
|
||||
GXTexCoord2s16(1, 0);
|
||||
GXPosition3s16(x + polyWidth, y + polyHeight, 0);
|
||||
GXTexCoord2s16(1, 1);
|
||||
GXPosition3s16(x, y + polyHeight, 0);
|
||||
GXTexCoord2s16(0, 1);
|
||||
GXEnd();
|
||||
}
|
||||
657
src/game/THPSimple.c
Executable file
657
src/game/THPSimple.c
Executable file
|
|
@ -0,0 +1,657 @@
|
|||
#include "game/THPSimple.h"
|
||||
#include "game/THPDraw.h"
|
||||
|
||||
#define ALIGN32(val) (((val) + 0x1F) & ~0x1F)
|
||||
|
||||
static void __THPSimpleDVDCallback(s32 result, DVDFileInfo *fileInfo);
|
||||
static s32 VideoDecode(void *arg0);
|
||||
static void THPAudioMixCallback(void);
|
||||
|
||||
UnkThpStruct10 SimpleControl;
|
||||
static u8 SoundBuffer[2][0x280];
|
||||
static u8 WorkBuffer[0x40];
|
||||
|
||||
static s32 SoundBufferIndex;
|
||||
static void *LastAudioBuffer;
|
||||
static void *CurAudioBuffer;
|
||||
static s32 bufIdx;
|
||||
static s32 AudioSystem;
|
||||
static void (*OldAIDCallback)();
|
||||
static s32 Initialized;
|
||||
|
||||
s32 THPSimpleInit(s32 arg0) {
|
||||
s32 temp_r31;
|
||||
|
||||
memset(&SimpleControl, 0, sizeof(SimpleControl));
|
||||
LCEnable();
|
||||
if (THPInit() == 0) {
|
||||
return 0;
|
||||
}
|
||||
temp_r31 = OSDisableInterrupts();
|
||||
AudioSystem = arg0;
|
||||
SoundBufferIndex = 0;
|
||||
LastAudioBuffer = NULL;
|
||||
CurAudioBuffer = NULL;
|
||||
OldAIDCallback = AIRegisterDMACallback(THPAudioMixCallback);
|
||||
if (OldAIDCallback == NULL && AudioSystem != 0) {
|
||||
AIRegisterDMACallback(NULL);
|
||||
OSRestoreInterrupts(temp_r31);
|
||||
return 0;
|
||||
}
|
||||
OSRestoreInterrupts(temp_r31);
|
||||
if (AudioSystem == 0) {
|
||||
memset(SoundBuffer, 0, sizeof(SoundBuffer));
|
||||
DCFlushRange(SoundBuffer, sizeof(SoundBuffer));
|
||||
AIInitDMA((u32) &SoundBuffer[SoundBufferIndex], sizeof(SoundBuffer[0]));
|
||||
AIStartDMA();
|
||||
}
|
||||
Initialized = 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void THPSimpleQuit(void) {
|
||||
s32 temp_r31;
|
||||
|
||||
LCDisable();
|
||||
temp_r31 = OSDisableInterrupts();
|
||||
if (OldAIDCallback) {
|
||||
AIRegisterDMACallback(OldAIDCallback);
|
||||
}
|
||||
OSRestoreInterrupts(temp_r31);
|
||||
Initialized = 0;
|
||||
}
|
||||
|
||||
s32 THPSimpleOpen(char *arg0) {
|
||||
s32 var_r31;
|
||||
s32 i;
|
||||
|
||||
if (Initialized == 0) {
|
||||
return 0;
|
||||
}
|
||||
if (SimpleControl.unk98 != 0) {
|
||||
return 0;
|
||||
}
|
||||
memset(&SimpleControl.unk80, 0, sizeof(SimpleControl.unk80));
|
||||
memset(SimpleControl.unk88, 0, sizeof(SimpleControl.unk88));
|
||||
if (DVDOpen(arg0, &SimpleControl.unk00) == 0) {
|
||||
return 0;
|
||||
}
|
||||
if (DVDReadPrio(&SimpleControl.unk00, &WorkBuffer, 0x40, 0, 2) < 0) {
|
||||
DVDClose(&SimpleControl.unk00);
|
||||
return 0;
|
||||
}
|
||||
memcpy(&SimpleControl.unk3C, &WorkBuffer, sizeof(SimpleControl.unk3C));
|
||||
if (strcmp(SimpleControl.unk3C.mMagic, "THP") != 0) {
|
||||
DVDClose(&SimpleControl.unk00);
|
||||
return 0;
|
||||
}
|
||||
if (SimpleControl.unk3C.mVersion != 0x10000) {
|
||||
DVDClose(&SimpleControl.unk00);
|
||||
return 0;
|
||||
}
|
||||
var_r31 = SimpleControl.unk3C.mCompInfoDataOffsets;
|
||||
if (DVDReadPrio(&SimpleControl.unk00, &WorkBuffer, 0x20, var_r31, 2) < 0) {
|
||||
DVDClose(&SimpleControl.unk00);
|
||||
return 0;
|
||||
}
|
||||
memcpy(&SimpleControl.unk6C, &WorkBuffer, sizeof(SimpleControl.unk6C));
|
||||
var_r31 += sizeof(SimpleControl.unk6C);
|
||||
SimpleControl.unk9F = 0;
|
||||
for (i = 0; i < SimpleControl.unk6C.mNumComponents; i++) {
|
||||
switch (SimpleControl.unk6C.mFrameComp[i]) {
|
||||
case 0:
|
||||
if (DVDReadPrio(&SimpleControl.unk00, &WorkBuffer, 0x20, var_r31, 2) < 0) {
|
||||
DVDClose(&SimpleControl.unk00);
|
||||
return 0;
|
||||
}
|
||||
memcpy(&SimpleControl.unk80, &WorkBuffer, sizeof(SimpleControl.unk80));
|
||||
var_r31 += sizeof(SimpleControl.unk80);
|
||||
break;
|
||||
case 1:
|
||||
if (DVDReadPrio(&SimpleControl.unk00, &WorkBuffer, 0x20, var_r31, 2) < 0) {
|
||||
DVDClose(&SimpleControl.unk00);
|
||||
return 0;
|
||||
}
|
||||
memcpy(SimpleControl.unk88, &WorkBuffer, sizeof(SimpleControl.unk88));
|
||||
SimpleControl.unk9F = 1;
|
||||
var_r31 += sizeof(SimpleControl.unk88);
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
SimpleControl.unkA0 = SimpleControl.unk3C.mMovieDataOffsets;
|
||||
SimpleControl.unkB4 = SimpleControl.unk3C.mFirstFrameSize;
|
||||
SimpleControl.unkB0 = 0;
|
||||
SimpleControl.unkB8 = 0;
|
||||
SimpleControl.unkA4 = 0;
|
||||
SimpleControl.unk144[0].unk0C = -1;
|
||||
SimpleControl.unkAC = 0;
|
||||
SimpleControl.unk194 = 0;
|
||||
SimpleControl.unk198 = 0;
|
||||
SimpleControl.unk9C = 0;
|
||||
SimpleControl.unk9D = 0;
|
||||
SimpleControl.unk9E = 0;
|
||||
SimpleControl.unk98 = 1;
|
||||
SimpleControl.unkC0 = SimpleControl.unkBC;
|
||||
SimpleControl.unkC8 = 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
s32 THPSimpleClose(void) {
|
||||
if (SimpleControl.unk98 != 0 && SimpleControl.unk9C == 0) {
|
||||
if (SimpleControl.unk9F != 0) {
|
||||
if (SimpleControl.unk9D == 1) {
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
SimpleControl.unk9D = 0;
|
||||
}
|
||||
if (SimpleControl.unkA8 == 0) {
|
||||
SimpleControl.unk98 = 0;
|
||||
DVDClose(&SimpleControl.unk00);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 THPSimpleCalcNeedMemory(void) {
|
||||
s32 var_r31;
|
||||
|
||||
if (SimpleControl.unk98 != 0) {
|
||||
var_r31 = ALIGN32(SimpleControl.unk3C.mBufferSize) * 10;
|
||||
var_r31 += ALIGN32(SimpleControl.unk80.unk00 * SimpleControl.unk80.unk04);
|
||||
var_r31 += ALIGN32(SimpleControl.unk80.unk00 * SimpleControl.unk80.unk04 / 4);
|
||||
var_r31 += ALIGN32(SimpleControl.unk80.unk00 * SimpleControl.unk80.unk04 / 4);
|
||||
var_r31 += ALIGN32(SimpleControl.unk80.unk00 * SimpleControl.unk80.unk04);
|
||||
var_r31 += ALIGN32(SimpleControl.unk80.unk00 * SimpleControl.unk80.unk04 / 4);
|
||||
var_r31 += ALIGN32(SimpleControl.unk80.unk00 * SimpleControl.unk80.unk04 / 4);
|
||||
if (SimpleControl.unk9F != 0) {
|
||||
var_r31 += ALIGN32(SimpleControl.unk3C.mAudioMaxSamples * 4) * 4;
|
||||
}
|
||||
var_r31 += 0x1000;
|
||||
return var_r31;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 THPSimpleSetBuffer(void *arg0) {
|
||||
u8 *var_r31;
|
||||
u32 temp_r28;
|
||||
u32 temp_r29;
|
||||
u32 i;
|
||||
|
||||
if (SimpleControl.unk98 != 0 && SimpleControl.unk9C == 0) {
|
||||
if (SimpleControl.unk9D == 1) {
|
||||
return 0;
|
||||
}
|
||||
temp_r28 = ALIGN32(SimpleControl.unk80.unk00 * SimpleControl.unk80.unk04);
|
||||
temp_r29 = ALIGN32(SimpleControl.unk80.unk00 * SimpleControl.unk80.unk04 / 4);
|
||||
var_r31 = arg0;
|
||||
for (i = 0; i < 2; i++) {
|
||||
SimpleControl.unk144[i].unk00 = var_r31;
|
||||
DCInvalidateRange(var_r31, temp_r28);
|
||||
var_r31 += temp_r28;
|
||||
SimpleControl.unk144[i].unk04 = var_r31;
|
||||
DCInvalidateRange(var_r31, temp_r29);
|
||||
var_r31 += temp_r29;
|
||||
SimpleControl.unk144[i].unk08 = var_r31;
|
||||
DCInvalidateRange(var_r31, temp_r29);
|
||||
var_r31 += temp_r29;
|
||||
}
|
||||
for (i = 0; i < 10; i++) {
|
||||
SimpleControl.unkCC[i].unk00 = (s32*) var_r31;
|
||||
var_r31 += ALIGN32(SimpleControl.unk3C.mBufferSize);
|
||||
SimpleControl.unkCC[i].unk08 = 0;
|
||||
}
|
||||
if (SimpleControl.unk9F != 0) {
|
||||
for (i = 0; i < 4; i++) {
|
||||
SimpleControl.unk164[i].unk00 = var_r31;
|
||||
SimpleControl.unk164[i].unk04 = var_r31;
|
||||
SimpleControl.unk164[i].unk08 = 0;
|
||||
var_r31 += ALIGN32(SimpleControl.unk3C.mAudioMaxSamples * 4);
|
||||
}
|
||||
}
|
||||
SimpleControl.unk94 = var_r31;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline void THPSimpleInlineFunc(void) {
|
||||
if (SimpleControl.unkB8 > SimpleControl.unk3C.mNumFrames - 1) {
|
||||
if (SimpleControl.unk9E != 1) {
|
||||
return;
|
||||
}
|
||||
SimpleControl.unkB8 = 0;
|
||||
SimpleControl.unkA0 = SimpleControl.unk3C.mMovieDataOffsets;
|
||||
SimpleControl.unkB4 = SimpleControl.unk3C.mFirstFrameSize;
|
||||
}
|
||||
SimpleControl.unkA8 = 1;
|
||||
if (DVDReadAsyncPrio(&SimpleControl.unk00, SimpleControl.unkCC[SimpleControl.unkB0].unk00, SimpleControl.unkB4, SimpleControl.unkA0, __THPSimpleDVDCallback, 2) != 1) {
|
||||
SimpleControl.unkA8 = 0;
|
||||
SimpleControl.unkA4 = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void __THPSimpleDVDCallback(s32 result, DVDFileInfo *fileInfo) {
|
||||
s32 var_r31;
|
||||
|
||||
if (result == -1) {
|
||||
SimpleControl.unkA4 = 1;
|
||||
return;
|
||||
}
|
||||
if (result != -3) {
|
||||
SimpleControl.unkA8 = 0;
|
||||
SimpleControl.unkCC[SimpleControl.unkB0].unk04 = SimpleControl.unkB8;
|
||||
SimpleControl.unkB8++;
|
||||
SimpleControl.unkCC[SimpleControl.unkB0].unk08 = 1;
|
||||
SimpleControl.unkA0 += SimpleControl.unkB4;
|
||||
SimpleControl.unkB4 = *SimpleControl.unkCC[SimpleControl.unkB0].unk00;
|
||||
if (SimpleControl.unkB0 + 1 >= 10) {
|
||||
var_r31 = 0;
|
||||
} else {
|
||||
var_r31 = SimpleControl.unkB0 + 1;
|
||||
}
|
||||
SimpleControl.unkB0 = var_r31;
|
||||
if (SimpleControl.unkCC[SimpleControl.unkB0].unk08 == 0 && SimpleControl.unkA4 == 0 && SimpleControl.unk9C == 1) {
|
||||
THPSimpleInlineFunc();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
s32 THPSimplePreLoad(s32 arg0) {
|
||||
u32 var_r30;
|
||||
s32 var_r29;
|
||||
s32 i;
|
||||
|
||||
if (SimpleControl.unk98 != 0 && SimpleControl.unk9C == 0) {
|
||||
var_r30 = 10;
|
||||
if (arg0 == 0 && SimpleControl.unk3C.mNumFrames < 10) {
|
||||
var_r30 = SimpleControl.unk3C.mNumFrames;
|
||||
}
|
||||
for (i = 0; i < var_r30; i++) {
|
||||
if (DVDReadPrio(&SimpleControl.unk00, SimpleControl.unkCC[SimpleControl.unkB0].unk00, SimpleControl.unkB4, SimpleControl.unkA0, 2) < 0) {
|
||||
SimpleControl.unkA4 = 1;
|
||||
return 0;
|
||||
}
|
||||
SimpleControl.unkA0 += SimpleControl.unkB4;
|
||||
SimpleControl.unkB4 = *SimpleControl.unkCC[SimpleControl.unkB0].unk00;
|
||||
SimpleControl.unkCC[SimpleControl.unkB0].unk08 = 1;
|
||||
SimpleControl.unkCC[SimpleControl.unkB0].unk04 = SimpleControl.unkB8;
|
||||
if (SimpleControl.unkB0 + 1 >= 10) {
|
||||
var_r29 = 0;
|
||||
} else {
|
||||
var_r29 = SimpleControl.unkB0 + 1;
|
||||
}
|
||||
SimpleControl.unkB0 = var_r29;
|
||||
SimpleControl.unkB8++;
|
||||
if (SimpleControl.unkB8 > SimpleControl.unk3C.mNumFrames - 1 && SimpleControl.unk9E == 1) {
|
||||
SimpleControl.unkB8 = 0;
|
||||
SimpleControl.unkA0 = SimpleControl.unk3C.mMovieDataOffsets;
|
||||
SimpleControl.unkB4 = SimpleControl.unk3C.mFirstFrameSize;
|
||||
}
|
||||
}
|
||||
SimpleControl.unk9E = arg0;
|
||||
SimpleControl.unk9C = 1;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void THPSimpleAudioStart(void) {
|
||||
SimpleControl.unk9D = 1;
|
||||
}
|
||||
|
||||
void THPSimpleAudioStop(void) {
|
||||
SimpleControl.unk9D = 0;
|
||||
}
|
||||
|
||||
s32 THPSimpleLoadStop(void) {
|
||||
s32 i;
|
||||
|
||||
if (SimpleControl.unk98 != 0 && SimpleControl.unk9D == 0) {
|
||||
SimpleControl.unk9C = 0;
|
||||
if (SimpleControl.unkA8 != 0) {
|
||||
DVDCancel(&SimpleControl.unk00.cb);
|
||||
SimpleControl.unkA8 = 0;
|
||||
}
|
||||
for (i = 0; i < 10; i++) {
|
||||
SimpleControl.unkCC[i].unk08 = 0;
|
||||
}
|
||||
for (i = 0; i < 4; i++) {
|
||||
SimpleControl.unk164[i].unk08 = 0;
|
||||
}
|
||||
SimpleControl.unk144[0].unk0C = -1;
|
||||
SimpleControl.unkA0 = SimpleControl.unk3C.mMovieDataOffsets;
|
||||
SimpleControl.unkB4 = SimpleControl.unk3C.mFirstFrameSize;
|
||||
SimpleControl.unkB0 = 0;
|
||||
SimpleControl.unkB8 = 0;
|
||||
SimpleControl.unkA4 = 0;
|
||||
SimpleControl.unkAC = 0;
|
||||
SimpleControl.unk194 = 0;
|
||||
SimpleControl.unk198 = 0;
|
||||
SimpleControl.unkBC = SimpleControl.unkC0;
|
||||
SimpleControl.unkC8 = 0;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 THPSimpleDecode(void) {
|
||||
u8 *var_r29;
|
||||
s32 *var_r30;
|
||||
s32 temp_r27;
|
||||
s32 temp_r26;
|
||||
s32 temp_r25;
|
||||
s32 var_r28;
|
||||
s32 i;
|
||||
|
||||
if (SimpleControl.unkCC[SimpleControl.unkAC].unk08 != 0) {
|
||||
var_r30 = SimpleControl.unkCC[SimpleControl.unkAC].unk00 + 2;
|
||||
var_r29 = (u8*) (&SimpleControl.unkCC[SimpleControl.unkAC].unk00[SimpleControl.unk6C.mNumComponents] + 2);
|
||||
if (SimpleControl.unk9F != 0) {
|
||||
if (SimpleControl.unk164[SimpleControl.unk194].unk08 == 0) {
|
||||
for (i = 0; i < SimpleControl.unk6C.mNumComponents; var_r29 += *var_r30, var_r30++, i++) {
|
||||
switch (SimpleControl.unk6C.mFrameComp[i]) {
|
||||
case 0:
|
||||
if (VideoDecode(var_r29) == 0) {
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
temp_r26 = THPAudioDecode(SimpleControl.unk164[SimpleControl.unk194].unk00, var_r29, 0);
|
||||
temp_r27 = OSDisableInterrupts();
|
||||
SimpleControl.unk164[SimpleControl.unk194].unk08 = temp_r26;
|
||||
SimpleControl.unk164[SimpleControl.unk194].unk04 = SimpleControl.unk164[SimpleControl.unk194].unk00;
|
||||
OSRestoreInterrupts(temp_r27);
|
||||
SimpleControl.unk194++;
|
||||
if (SimpleControl.unk194 >= 4) {
|
||||
SimpleControl.unk194 = 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return 3;
|
||||
}
|
||||
} else {
|
||||
for (i = 0; i < SimpleControl.unk6C.mNumComponents; var_r29 += *var_r30, var_r30++, i++) {
|
||||
if ((s32) SimpleControl.unk6C.mFrameComp[i] != 0) {
|
||||
(void) i; // required to match. Optimized out unreachable code?
|
||||
} else if (VideoDecode(var_r29) == 0) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
SimpleControl.unkCC[SimpleControl.unkAC].unk08 = 0;
|
||||
if (SimpleControl.unkAC + 1 >= 10) {
|
||||
var_r28 = 0;
|
||||
} else {
|
||||
var_r28 = SimpleControl.unkAC + 1;
|
||||
}
|
||||
SimpleControl.unkAC = var_r28;
|
||||
temp_r25 = OSDisableInterrupts();
|
||||
if (SimpleControl.unkCC[SimpleControl.unkB0].unk08 == 0 && SimpleControl.unkA8 == 0 && SimpleControl.unkA4 == 0 && SimpleControl.unk9C == 1) {
|
||||
THPSimpleInlineFunc();
|
||||
}
|
||||
OSRestoreInterrupts(temp_r25);
|
||||
return 0;
|
||||
} else {
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
||||
static s32 VideoDecode(void *arg0) {
|
||||
s32 temp_r31;
|
||||
|
||||
bufIdx = (bufIdx + 1) & 1;
|
||||
temp_r31 = THPVideoDecode(arg0, SimpleControl.unk144[bufIdx].unk00, SimpleControl.unk144[bufIdx].unk04, SimpleControl.unk144[bufIdx].unk08, SimpleControl.unk94);
|
||||
if (temp_r31 == 0) {
|
||||
SimpleControl.unk144[0].unk0C = SimpleControl.unkCC[SimpleControl.unkAC].unk04;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 THPSimpleDrawCurrentFrame(GXRenderModeObj *arg0, GXColor *arg1, Mtx arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6) {
|
||||
if (SimpleControl.unk144[0].unk0C >= 0) {
|
||||
THPGXYuv2RgbSetup(arg0, arg1, arg2);
|
||||
THPGXYuv2RgbDraw(SimpleControl.unk144[bufIdx].unk00, SimpleControl.unk144[bufIdx].unk04, SimpleControl.unk144[bufIdx].unk08, arg3, arg4, SimpleControl.unk80.unk00, SimpleControl.unk80.unk04, arg5, arg6);
|
||||
THPGXRestore();
|
||||
return SimpleControl.unk144[0].unk0C;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static u16 VolumeTable[] = {
|
||||
0x0000, 0x0002, 0x0008, 0x0012, 0x0020, 0x0032, 0x0049, 0x0063,
|
||||
0x0082, 0x00A4, 0x00CB, 0x00F5, 0x0124, 0x0157, 0x018E, 0x01C9,
|
||||
0x0208, 0x024B, 0x0292, 0x02DD, 0x032C, 0x037F, 0x03D7, 0x0432,
|
||||
0x0492, 0x04F5, 0x055D, 0x05C9, 0x0638, 0x06AC, 0x0724, 0x07A0,
|
||||
0x0820, 0x08A4, 0x092C, 0x09B8, 0x0A48, 0x0ADD, 0x0B75, 0x0C12,
|
||||
0x0CB2, 0x0D57, 0x0DFF, 0x0EAC, 0x0F5D, 0x1012, 0x10CA, 0x1187,
|
||||
0x1248, 0x130D, 0x13D7, 0x14A4, 0x1575, 0x164A, 0x1724, 0x1801,
|
||||
0x18E3, 0x19C8, 0x1AB2, 0x1BA0, 0x1C91, 0x1D87, 0x1E81, 0x1F7F,
|
||||
0x2081, 0x2187, 0x2291, 0x239F, 0x24B2, 0x25C8, 0x26E2, 0x2801,
|
||||
0x2923, 0x2A4A, 0x2B75, 0x2CA3, 0x2DD6, 0x2F0D, 0x3048, 0x3187,
|
||||
0x32CA, 0x3411, 0x355C, 0x36AB, 0x37FF, 0x3956, 0x3AB1, 0x3C11,
|
||||
0x3D74, 0x3EDC, 0x4048, 0x41B7, 0x432B, 0x44A3, 0x461F, 0x479F,
|
||||
0x4923, 0x4AAB, 0x4C37, 0x4DC7, 0x4F5C, 0x50F4, 0x5290, 0x5431,
|
||||
0x55D6, 0x577E, 0x592B, 0x5ADC, 0x5C90, 0x5E49, 0x6006, 0x61C7,
|
||||
0x638C, 0x6555, 0x6722, 0x68F4, 0x6AC9, 0x6CA2, 0x6E80, 0x7061,
|
||||
0x7247, 0x7430, 0x761E, 0x7810, 0x7A06, 0x7C00, 0x7DFE, 0x8000
|
||||
};
|
||||
|
||||
static void MixAudio(void *arg0, void *arg1, u32 arg2) {
|
||||
s32 var_r31;
|
||||
u32 var_r27;
|
||||
u32 var_r28;
|
||||
s32 i;
|
||||
u16 temp_r24;
|
||||
s16 *var_r26;
|
||||
s16 *var_r30;
|
||||
s16 *var_r29;
|
||||
|
||||
if (arg1) {
|
||||
if (SimpleControl.unk98 != 0 && SimpleControl.unk9D == 1 && SimpleControl.unk9F != 0) {
|
||||
var_r28 = arg2;
|
||||
var_r30 = arg0;
|
||||
var_r26 = arg1;
|
||||
while (1) {
|
||||
if (SimpleControl.unk164[SimpleControl.unk198].unk08 == 0) {
|
||||
break;
|
||||
}
|
||||
if (SimpleControl.unk164[SimpleControl.unk198].unk08 >= var_r28) {
|
||||
var_r27 = var_r28;
|
||||
} else {
|
||||
var_r27 = SimpleControl.unk164[SimpleControl.unk198].unk08;
|
||||
}
|
||||
var_r29 = SimpleControl.unk164[SimpleControl.unk198].unk04;
|
||||
for (i = 0; i < var_r27; i++) {
|
||||
if (SimpleControl.unkC8 != 0) {
|
||||
SimpleControl.unkC8--;
|
||||
SimpleControl.unkBC += SimpleControl.unkC4;
|
||||
} else {
|
||||
SimpleControl.unkBC = SimpleControl.unkC0;
|
||||
}
|
||||
temp_r24 = VolumeTable[(s32) SimpleControl.unkBC];
|
||||
var_r31 = *var_r26 + ((temp_r24 * *var_r29) >> 0xF);
|
||||
if (var_r31 < -0x8000) {
|
||||
var_r31 = -0x8000;
|
||||
}
|
||||
if (var_r31 > 0x7FFF) {
|
||||
var_r31 = 0x7FFF;
|
||||
}
|
||||
*var_r30 = var_r31;
|
||||
var_r30++;
|
||||
var_r26++;
|
||||
var_r29++;
|
||||
var_r31 = *var_r26 + ((temp_r24 * *var_r29) >> 0xF);
|
||||
if (var_r31 < -0x8000) {
|
||||
var_r31 = -0x8000;
|
||||
}
|
||||
if (var_r31 > 0x7FFF) {
|
||||
var_r31 = 0x7FFF;
|
||||
}
|
||||
*var_r30 = var_r31;
|
||||
var_r30++;
|
||||
var_r26++;
|
||||
var_r29++;
|
||||
}
|
||||
var_r28 -= var_r27;
|
||||
SimpleControl.unk164[SimpleControl.unk198].unk08 -= var_r27;
|
||||
SimpleControl.unk164[SimpleControl.unk198].unk04 = var_r29;
|
||||
if (SimpleControl.unk164[SimpleControl.unk198].unk08 == 0) {
|
||||
SimpleControl.unk198++;
|
||||
if (SimpleControl.unk198 >= 4) {
|
||||
SimpleControl.unk198 = 0;
|
||||
}
|
||||
}
|
||||
if (var_r28 == 0) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
memcpy(var_r30, var_r26, var_r28 * 4);
|
||||
} else {
|
||||
memcpy(arg0, arg1, arg2 * 4);
|
||||
}
|
||||
} else if (SimpleControl.unk98 != 0 && SimpleControl.unk9D == 1 && SimpleControl.unk9F != 0) {
|
||||
var_r28 = arg2;
|
||||
var_r30 = arg0;
|
||||
while (1) {
|
||||
if (SimpleControl.unk164[SimpleControl.unk198].unk08 == 0) {
|
||||
break;
|
||||
}
|
||||
if (SimpleControl.unk164[SimpleControl.unk198].unk08 >= var_r28) {
|
||||
var_r27 = var_r28;
|
||||
} else {
|
||||
var_r27 = SimpleControl.unk164[SimpleControl.unk198].unk08;
|
||||
}
|
||||
var_r29 = SimpleControl.unk164[SimpleControl.unk198].unk04;
|
||||
for (i = 0; i < var_r27; i++) {
|
||||
if (SimpleControl.unkC8 != 0) {
|
||||
SimpleControl.unkC8--;
|
||||
SimpleControl.unkBC += SimpleControl.unkC4;
|
||||
} else {
|
||||
SimpleControl.unkBC = SimpleControl.unkC0;
|
||||
}
|
||||
temp_r24 = VolumeTable[(s32) SimpleControl.unkBC];
|
||||
var_r31 = (temp_r24 * *var_r29) >> 0xF;
|
||||
if (var_r31 < -0x8000) {
|
||||
var_r31 = -0x8000;
|
||||
}
|
||||
if (var_r31 > 0x7FFF) {
|
||||
var_r31 = 0x7FFF;
|
||||
}
|
||||
*var_r30 = var_r31;
|
||||
var_r30++;
|
||||
var_r29++;
|
||||
var_r31 = (temp_r24 * *var_r29) >> 0xF;
|
||||
if (var_r31 < -0x8000) {
|
||||
var_r31 = -0x8000;
|
||||
}
|
||||
if (var_r31 > 0x7FFF) {
|
||||
var_r31 = 0x7FFF;
|
||||
}
|
||||
*var_r30 = var_r31;
|
||||
var_r30++;
|
||||
var_r29++;
|
||||
}
|
||||
var_r28 -= var_r27;
|
||||
SimpleControl.unk164[SimpleControl.unk198].unk08 -= var_r27;
|
||||
SimpleControl.unk164[SimpleControl.unk198].unk04 = var_r29;
|
||||
if (SimpleControl.unk164[SimpleControl.unk198].unk08 == 0) {
|
||||
SimpleControl.unk198++;
|
||||
if (SimpleControl.unk198 >= 4) {
|
||||
SimpleControl.unk198 = 0;
|
||||
}
|
||||
}
|
||||
if (var_r28 == 0) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
memset(var_r30, 0, var_r28 * 4);
|
||||
} else {
|
||||
memset(arg0, 0, arg2 * 4);
|
||||
}
|
||||
}
|
||||
|
||||
s32 THPSimpleGetVideoInfo(UnkThpStruct04 *arg0) {
|
||||
if (SimpleControl.unk98 != 0) {
|
||||
memcpy(arg0, &SimpleControl.unk80, 8);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 THPSimpleGetTotalFrame(void) {
|
||||
if (SimpleControl.unk98 != 0) {
|
||||
return SimpleControl.unk3C.mNumFrames;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void THPAudioMixCallback(void) {
|
||||
s32 temp_r31;
|
||||
|
||||
if (AudioSystem == 0) {
|
||||
SoundBufferIndex ^= 1;
|
||||
AIInitDMA((u32) SoundBuffer[SoundBufferIndex], sizeof(SoundBuffer[0]));
|
||||
temp_r31 = OSEnableInterrupts();
|
||||
MixAudio(SoundBuffer[SoundBufferIndex], 0, 0xA0);
|
||||
DCFlushRange(SoundBuffer[SoundBufferIndex], sizeof(SoundBuffer[0]));
|
||||
OSRestoreInterrupts(temp_r31);
|
||||
} else {
|
||||
if (AudioSystem == 1) {
|
||||
if (LastAudioBuffer) {
|
||||
CurAudioBuffer = LastAudioBuffer;
|
||||
}
|
||||
OldAIDCallback();
|
||||
LastAudioBuffer = (u8*) AIGetDMAStartAddr() + 0x80000000;
|
||||
} else {
|
||||
OldAIDCallback();
|
||||
CurAudioBuffer = (u8*) AIGetDMAStartAddr() + 0x80000000;
|
||||
}
|
||||
SoundBufferIndex ^= 1;
|
||||
AIInitDMA((u32) SoundBuffer[SoundBufferIndex], sizeof(SoundBuffer[0]));
|
||||
temp_r31 = OSEnableInterrupts();
|
||||
if (CurAudioBuffer) {
|
||||
DCInvalidateRange(CurAudioBuffer, sizeof(SoundBuffer[0]));
|
||||
}
|
||||
MixAudio(SoundBuffer[SoundBufferIndex], CurAudioBuffer, 0xA0);
|
||||
DCFlushRange(SoundBuffer[SoundBufferIndex], sizeof(SoundBuffer[0]));
|
||||
OSRestoreInterrupts(temp_r31);
|
||||
}
|
||||
}
|
||||
|
||||
s32 THPSimpleSetVolume(s32 left, s32 right) {
|
||||
s32 temp_r29;
|
||||
|
||||
if (SimpleControl.unk98 != 0 && SimpleControl.unk9F != 0) {
|
||||
if (left > 127) {
|
||||
left = 127;
|
||||
}
|
||||
if (left < 0) {
|
||||
left = 0;
|
||||
}
|
||||
if (right > 60000) {
|
||||
right = 60000;
|
||||
}
|
||||
if (right < 0) {
|
||||
right = 0;
|
||||
}
|
||||
temp_r29 = OSDisableInterrupts();
|
||||
SimpleControl.unkC0 = left;
|
||||
if (right != 0) {
|
||||
SimpleControl.unkC8 = (right << 5);
|
||||
SimpleControl.unkC4 = (SimpleControl.unkC0 - SimpleControl.unkBC) / SimpleControl.unkC8;
|
||||
} else {
|
||||
SimpleControl.unkC8 = 0;
|
||||
SimpleControl.unkBC = SimpleControl.unkC0;
|
||||
}
|
||||
OSRestoreInterrupts(temp_r29);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -160,7 +160,7 @@ void HuAudFXPanning(s32 arg0, s16 arg1) {
|
|||
}
|
||||
}
|
||||
|
||||
void HuAudFXListnerSet(s32 arg0, s32 arg1, float arg2, float arg3) {
|
||||
void HuAudFXListnerSet(Vec* arg0, Vec* arg1, float arg2, float arg3) {
|
||||
if (omSysExitReq == 0) {
|
||||
HuAudFXListnerSetEX(arg0, arg1,
|
||||
arg2 + Snd3DDistOffset,
|
||||
|
|
@ -171,7 +171,7 @@ void HuAudFXListnerSet(s32 arg0, s32 arg1, float arg2, float arg3) {
|
|||
}
|
||||
}
|
||||
|
||||
void HuAudFXListnerSetEX(s32 arg0, s32 arg1, float sndDist, float sndSpeed, float arg4, float arg5, float arg6) {
|
||||
void HuAudFXListnerSetEX(Vec* arg0, Vec* arg1, float sndDist, float sndSpeed, float arg4, float arg5, float arg6) {
|
||||
UnkMsmStruct_02 sp1C;
|
||||
|
||||
if (omSysExitReq == 0) {
|
||||
|
|
|
|||
|
|
@ -41,8 +41,8 @@ extern void BoardPlayerMotionEndWait(s32);
|
|||
extern void BoardPlayerMotionShiftSet(s32, s32, f32, f32, s32);
|
||||
extern void BoardPlayerCoinsAdd(s32, s32);
|
||||
extern void BoardRotateDiceNumbers(s32);
|
||||
extern void BoardCameraAnimBlendSet(s32, s16, s16);
|
||||
extern s32 BoardPlayerAnimBlendCheck(s32);
|
||||
extern void BoardCameraMotBlendSet(s32, s16, s16);
|
||||
extern s32 BoardPlayerMotBlendCheck(s32);
|
||||
|
||||
static omObjData *coinChgObj[4] = {
|
||||
NULL,
|
||||
|
|
@ -64,7 +64,7 @@ static s32 coinDigitMdl[10] = {
|
|||
MAKE_DATA_NUM(DATADIR_BOARD, 21),
|
||||
};
|
||||
|
||||
void BoardLandBlueExec(s32 player, s16 space) {
|
||||
void BoardLandBlueExec(s32 player, s32 space) {
|
||||
Vec pos;
|
||||
s32 i;
|
||||
s8 coin_chg;
|
||||
|
|
@ -72,8 +72,8 @@ void BoardLandBlueExec(s32 player, s16 space) {
|
|||
|
||||
|
||||
BoardCameraViewSet(2);
|
||||
BoardPlayerAnimBlendSet(player, 0, 15);
|
||||
while (BoardPlayerAnimBlendCheck(player) == 0) {
|
||||
BoardPlayerMotBlendSet(player, 0, 15);
|
||||
while (BoardPlayerMotBlendCheck(player) == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
if (_CheckFlag(FLAG_ID_MAKE(1, 11)) != 0) {
|
||||
|
|
@ -105,7 +105,7 @@ void BoardLandBlueExec(s32 player, s16 space) {
|
|||
BoardRotateDiceNumbers(player);
|
||||
}
|
||||
|
||||
void BoardLandRedExec(s32 player, s16 space) {
|
||||
void BoardLandRedExec(s32 player, s32 space) {
|
||||
Vec pos;
|
||||
s32 i;
|
||||
s8 coin_chg;
|
||||
|
|
@ -113,8 +113,8 @@ void BoardLandRedExec(s32 player, s16 space) {
|
|||
|
||||
BoardCameraViewSet(2);
|
||||
omVibrate(player, 12, 6, 6);
|
||||
BoardPlayerAnimBlendSet(player, 0, 15);
|
||||
while (BoardPlayerAnimBlendCheck(player) == 0) {
|
||||
BoardPlayerMotBlendSet(player, 0, 15);
|
||||
while (BoardPlayerMotBlendCheck(player) == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
if (_CheckFlag(FLAG_ID_MAKE(1, 11)) != 0) {
|
||||
|
|
@ -162,7 +162,7 @@ s8 BoardCoinChgCreate(Vec *pos, s8 value) {
|
|||
|
||||
obj = omAddObjEx(boardObjMan, 266, 0, 0, -1, &UpdateCoinChg);
|
||||
coinChgObj[i] = obj;
|
||||
coin_chg = (coinChg *)obj->work;
|
||||
coin_chg = OM_GET_WORK_PTR(obj, coinChg);
|
||||
coin_chg->hide = 0;
|
||||
coin_chg->update = 0;
|
||||
coin_chg->minus = (value < 0) ? 1 : 0;
|
||||
|
|
@ -189,7 +189,7 @@ s32 BoardCoinChgExist(s32 index) {
|
|||
return index;
|
||||
}
|
||||
if (coinChgObj[index - 1] != 0) {
|
||||
coin_chg = (coinChg *)coinChgObj[index - 1]->work;
|
||||
coin_chg = OM_GET_WORK_PTR(coinChgObj[index - 1], coinChg);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
|
|
@ -201,7 +201,7 @@ void BoardCoinChgHide(s32 index) {
|
|||
return;
|
||||
}
|
||||
if (coinChgObj[index - 1] != 0) {
|
||||
((coinChg *)coinChgObj[index - 1]->work)->hide = 1;
|
||||
OM_GET_WORK_PTR(coinChgObj[index - 1], coinChg)->hide = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -251,7 +251,7 @@ static void CreateCoinChg(coinChg *coin_chg, Vec *pos) {
|
|||
static void UpdateCoinChg(omObjData *object) {
|
||||
coinChg *coin_chg;
|
||||
|
||||
coin_chg = (coinChg *)object->work;
|
||||
coin_chg = OM_GET_WORK_PTR(object, coinChg);
|
||||
if ((coin_chg->hide != 0) || (BoardIsKill() != 0)) {
|
||||
if (coin_chg->coin_model != -1) {
|
||||
BoardModelKill(coin_chg->coin_model);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
1183
src/game/board/model.c
Normal file
1183
src/game/board/model.c
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -41,7 +41,7 @@ extern void BoardModelMotionCreate(s16, s32);
|
|||
extern void BoardModelMotionKill(s16, s32);
|
||||
extern s32 BoardModelMotionEndCheck(s16);
|
||||
extern s32 BoardModelMotionStart(s16, s32, s32);
|
||||
extern s32 BoardModelMotionShiftSet(s16, s32, f32, f32, s32);
|
||||
extern s32 BoardModelMotionShiftSet(s16, s32, f32, f32, u32);
|
||||
extern void BoardModelMotionSpeedSet(s16, f32);
|
||||
extern void BoardModelMotionTimeSet(s16, f32);
|
||||
extern f32 BoardModelMotionTimeGet(s16);
|
||||
|
|
@ -52,16 +52,16 @@ extern void BoardModelAttrReset(s16, s32);
|
|||
//// #include "game/board/tutorial.h"
|
||||
extern BoardTutorialHookExec(s16, s32);
|
||||
//// #include "game/board/com.h"
|
||||
extern void fn_8007185C(s32, s32);
|
||||
extern void BoardComUseItemSet(s32, s32);
|
||||
//// #include "game/board/overhead.h"
|
||||
extern void fn_800729A4(s32);
|
||||
extern void fn_80072DA8(s32);
|
||||
//// #include "game/board/dice_roll.h"
|
||||
extern void BoardViewOverheadExec(s32);
|
||||
extern void BoardViewMapExec(s32);
|
||||
//// #include "game/board/roll.h"
|
||||
extern s32 fn_80085CC8(s32);
|
||||
extern void fn_80085EB4(void);
|
||||
//// #include "game/chrman.h"
|
||||
extern void CharModelKillIndex(s16);
|
||||
extern void CharModelSetStepType(s16, s32);
|
||||
extern void CharModelDataClose(s16);
|
||||
extern void CharModelStepTypeSet(s16, s32);
|
||||
////
|
||||
|
||||
static void UpdateJunctionGfx(omObjData*);
|
||||
|
|
@ -82,7 +82,7 @@ s32 DoDebugMove(s32, s16*);
|
|||
s32 DoSparkSpace(s32, s16*);
|
||||
s32 ExecJunction(s32, s16*);
|
||||
s32 MegaPlayerPassFunc(s32, s16);
|
||||
s32 BoardPlayerAnimBlendCheck(s32);
|
||||
s32 BoardPlayerMotBlendCheck(s32);
|
||||
|
||||
typedef struct bitcopy {
|
||||
struct {
|
||||
|
|
@ -115,7 +115,7 @@ static s16 suitPlayerMdl = -1;
|
|||
static s16 suitCurrMot = -1;
|
||||
|
||||
static s32 diceJumpObj[4] = {0, 0, 0, 0};
|
||||
static s32 animDoneF[4] = {0, 0, 0, 0};
|
||||
static s32 motDoneF[4] = {0, 0, 0, 0};
|
||||
static s16 bowserSuitMot[5] = {-1, -1, -1, -1, -1};
|
||||
char* lbl_8013993C[] = {
|
||||
"eye1",
|
||||
|
|
@ -179,7 +179,7 @@ void BoardPlayerInit(void) {
|
|||
|
||||
for (var_r31 = 0; var_r31 < 4; var_r31++) {
|
||||
GWPlayer[var_r31].space_curr = temp_r30;
|
||||
fn_80062D90(var_r31);
|
||||
BoardPlayerCornerPosSet(var_r31);
|
||||
BoardPlayerSizeSet(var_r31, 0);
|
||||
GWPlayer[var_r31].color = 0;
|
||||
GWPlayer[var_r31].bowser_suit = 0;
|
||||
|
|
@ -190,7 +190,7 @@ void BoardPlayerInit(void) {
|
|||
}
|
||||
|
||||
for (var_r31 = 0; var_r31 < 4; var_r31++) {
|
||||
fn_80062D90(var_r31);
|
||||
BoardPlayerCornerPosSet(var_r31);
|
||||
if (BoardPlayerAutoSizeGet(var_r31) != 0) {
|
||||
BoardPlayerAutoSizeSet(var_r31, BoardPlayerAutoSizeGet(var_r31));
|
||||
BoardStatusHammerShowSet(var_r31, 0);
|
||||
|
|
@ -227,7 +227,7 @@ void BoardPlayerModelInit(void) {
|
|||
for (var_r31 = 0; var_r31 < 4; var_r31++) {
|
||||
preTurnHook[var_r31] = 0;
|
||||
postTurnHook[var_r31] = 0;
|
||||
animDoneF[var_r31] = 0;
|
||||
motDoneF[var_r31] = 0;
|
||||
diceJumpObj[var_r31] = 0;
|
||||
temp_r22 = &GWPlayer[var_r31];
|
||||
temp_r27 = temp_r22;
|
||||
|
|
@ -266,7 +266,7 @@ void BoardPlayerModelInit(void) {
|
|||
GWPlayer[var_r31].diff = GWPlayerCfg[var_r31].diff;
|
||||
GWPlayerCfg[var_r31].diff = GWPlayerCfg[var_r31].diff;
|
||||
temp_r27->space_prev = -1;
|
||||
CharModelKillIndex(GWPlayer[var_r31].character);
|
||||
CharModelDataClose(GWPlayer[var_r31].character);
|
||||
}
|
||||
CharModelLayerSetAll(2);
|
||||
}
|
||||
|
|
@ -375,14 +375,14 @@ s32 BoardPlayerItemCount(s32 arg0) {
|
|||
return var_r30;
|
||||
}
|
||||
|
||||
void fn_80062D90(s32 arg0) {
|
||||
void BoardPlayerCornerPosSet(s32 arg0) {
|
||||
Vec sp8;
|
||||
|
||||
BoardPlayerCurrSpacePosDirGet(arg0, &sp8);
|
||||
BoardPlayerCornerPosGet(arg0, &sp8);
|
||||
BoardPlayerPosSetV(arg0, &sp8);
|
||||
}
|
||||
|
||||
void BoardPlayerCurrSpacePosDirGet(s32 arg0, Point3d* arg1) {
|
||||
void BoardPlayerCornerPosGet(s32 arg0, Point3d* arg1) {
|
||||
s32 var_r31;
|
||||
s32 var_r30;
|
||||
s32 var_r29;
|
||||
|
|
@ -400,7 +400,7 @@ void BoardPlayerCurrSpacePosDirGet(s32 arg0, Point3d* arg1) {
|
|||
var_r29 += 1;
|
||||
}
|
||||
}
|
||||
BoardSpaceDirPosGet(temp_r28, var_r29, arg1);
|
||||
BoardSpaceCornerPosGet(temp_r28, var_r29, arg1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -531,7 +531,7 @@ void BoardPlayerMotionStart(s32 arg0, s32 arg1, s32 arg2) {
|
|||
}
|
||||
}
|
||||
|
||||
void BoardPlayerMotionShiftSet(s32 arg0, s32 arg1, f32 arg8, f32 arg9, s32 arg2) {
|
||||
void BoardPlayerMotionShiftSet(s32 arg0, s32 arg1, f32 arg8, f32 arg9, u32 arg2) {
|
||||
PlayerState* player;
|
||||
s32 temp_r29;
|
||||
|
||||
|
|
@ -607,11 +607,11 @@ void BoardPlayerSizeSet(s32 arg0, s32 arg1) {
|
|||
temp_r27 = BoardPlayerGet(arg0);
|
||||
temp_r27->size = arg1;
|
||||
if (arg1 == 2) {
|
||||
CharModelSetStepType(GWPlayer[arg0].character, 4);
|
||||
CharModelStepTypeSet(GWPlayer[arg0].character, 4);
|
||||
} else if (arg1 == 1) {
|
||||
CharModelSetStepType(GWPlayer[arg0].character, 5);
|
||||
CharModelStepTypeSet(GWPlayer[arg0].character, 5);
|
||||
} else {
|
||||
CharModelSetStepType(GWPlayer[arg0].character, 0);
|
||||
CharModelStepTypeSet(GWPlayer[arg0].character, 0);
|
||||
}
|
||||
BoardModelScaleSetV(BoardPlayerModelGet(arg0), &temp_r4[arg1]);
|
||||
}
|
||||
|
|
@ -682,7 +682,7 @@ void BoardPlayerPostTurnHookSet(s32 arg0, s32 (*arg1)()) {
|
|||
|
||||
void BoardPlayerTurnExec(s32 arg0) {
|
||||
BoardPauseEnableSet(1);
|
||||
fn_8007185C(arg0, -1);
|
||||
BoardComUseItemSet(arg0, -1);
|
||||
GWSystem.field31_bit4 = 0xF;
|
||||
_ClearFlag(0x10016);
|
||||
_ClearFlag(0x1000E);
|
||||
|
|
@ -741,11 +741,11 @@ void BoardPlayerTurnRollExec(s32 arg0) {
|
|||
break;
|
||||
case -3:
|
||||
fn_80085EB4();
|
||||
fn_80072DA8(arg0);
|
||||
BoardViewMapExec(arg0);
|
||||
break;
|
||||
case -4:
|
||||
fn_80085EB4();
|
||||
fn_800729A4(arg0);
|
||||
BoardViewOverheadExec(arg0);
|
||||
break;
|
||||
}
|
||||
} while (temp_r30 <= 0);
|
||||
|
|
@ -918,10 +918,10 @@ void BoardPlayerZoomRestore(s32 arg0) {
|
|||
var_r31 = (var_r31 + 1) & 3;
|
||||
(void)var_r29; //
|
||||
}
|
||||
BoardSpaceDirPosGet(temp_r27, var_r29, &sp18);
|
||||
BoardPlayerAnimBlendSet(arg0, 0, 0xF);
|
||||
BoardSpaceCornerPosGet(temp_r27, var_r29, &sp18);
|
||||
BoardPlayerMotBlendSet(arg0, 0, 0xF);
|
||||
|
||||
while (BoardPlayerAnimBlendCheck(arg0) == 0) {
|
||||
while (BoardPlayerMotBlendCheck(arg0) == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardRotateDiceNumbers(arg0);
|
||||
|
|
|
|||
|
|
@ -1,18 +1,39 @@
|
|||
#include "game/gamework_data.h"
|
||||
#include "game/flag.h"
|
||||
#include "game/board/main.h"
|
||||
#include "game/board/player.h"
|
||||
#include "game/board/space.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/data.h"
|
||||
#include "game/sprite.h"
|
||||
|
||||
#include "math.h"
|
||||
#include "string.h"
|
||||
|
||||
extern void omVibrate(s16, s16, s16, s16);
|
||||
|
||||
|
||||
extern s16 BoardStarHostMdlGet(void);
|
||||
extern void BoardModelPosSetV(s16 model, Vec *pos);
|
||||
extern s16 BoardModelCreate(s32 file, s32 *data, s32 arg3);
|
||||
extern s16 BoardModelIDGet(s16 model);
|
||||
|
||||
|
||||
static BoardSpace spaceData[2][256];
|
||||
s16 boardSpaceStarTbl[8];
|
||||
static GXTexObj spaceHiliteTex;
|
||||
static GXTexObj spaceTex;
|
||||
s16 boardSpaceStarTbl[8];
|
||||
static BoardSpace spaceData[2][256];
|
||||
|
||||
static s8 spaceImgIdx[12] = {
|
||||
0, 1, 2, 7,
|
||||
6, 5, 3, 4,
|
||||
9, 10, 11, 0
|
||||
};
|
||||
|
||||
static s8 spaceHiliteImgIdx[12] = {
|
||||
-1, 0, 1, 1,
|
||||
2, 2, 2, 2,
|
||||
-1, 3, -1, -1
|
||||
};
|
||||
|
||||
static s16 spaceCnt[2];
|
||||
static u32 spaceAttr[2];
|
||||
|
|
@ -28,11 +49,13 @@ static s32 spaceDrawCnt;
|
|||
static s16 spaceDrawF;
|
||||
|
||||
static s16 spaceDrawMdl = -1;
|
||||
static s16 starMdl = -1;
|
||||
static s16 starPlatMdl = -1;
|
||||
|
||||
static s32 ExecPipeSpace(s32 player, s32 space);
|
||||
|
||||
extern s8 boardTutorialBlockF;
|
||||
extern s32 boardTutorialBlockPos;
|
||||
|
||||
s32 BoardSpaceRotGet(s32 layer, s32 index, Vec *rot);
|
||||
s32 BoardSpaceStarGet(s32 index);
|
||||
s32 BoardSpaceStarGetCurr(void);
|
||||
|
||||
void BoardSpaceWalkEventFuncSet(BoardSpaceEventFunc func)
|
||||
{
|
||||
|
|
@ -69,7 +92,7 @@ s32 BoardSpaceWalkMiniEventExec(void)
|
|||
return ret;
|
||||
}
|
||||
|
||||
s16 BoardSpaceCountGet(s32 layer)
|
||||
s32 BoardSpaceCountGet(s32 layer)
|
||||
{
|
||||
return spaceCnt[layer];
|
||||
}
|
||||
|
|
@ -281,7 +304,7 @@ s32 BoardSpaceLinkTransformGet(s32 flag, Vec *pos, Vec *rot, Vec *scale)
|
|||
return -1;
|
||||
}
|
||||
|
||||
void BoardSpaceStarSet(s32 space)
|
||||
void BoardSpaceHostSet(s32 space)
|
||||
{
|
||||
s16 host_space;
|
||||
Vec pos;
|
||||
|
|
@ -292,9 +315,9 @@ void BoardSpaceStarSet(s32 space)
|
|||
BoardModelPosSetV(BoardStarHostMdlGet(), &pos);
|
||||
}
|
||||
|
||||
static inline s16 BoardStarMdlGet(void)
|
||||
static inline s16 StarPlatGetMdl(void)
|
||||
{
|
||||
return starMdl;
|
||||
return starPlatMdl;
|
||||
}
|
||||
|
||||
static inline s32 BoardStarSpaceTypeGet(s16 index)
|
||||
|
|
@ -311,13 +334,13 @@ void BoardSpaceStarSetIndex(s32 index)
|
|||
BoardSpaceTypeSet(0, boardSpaceStarTbl[GWSystem.star_pos], 1);
|
||||
}
|
||||
GWSystem.star_pos = index & 0x7;
|
||||
BoardSpaceStarSet(BoardSpaceStarGetCurr());
|
||||
BoardSpaceHostSet(BoardSpaceStarGetCurr());
|
||||
space = BoardSpaceLinkFlagSearch(0, BoardSpaceStarGetCurr(), 0x04000000);
|
||||
BoardSpacePosGet(0, space, &pos);
|
||||
BoardModelPosSetV(BoardStarMdlGet(), &pos);
|
||||
BoardModelPosSetV(StarPlatGetMdl(), &pos);
|
||||
BoardSpaceRotGet(0, space, &rot);
|
||||
BoardModelRotYSet(BoardStarMdlGet(), rot.y);
|
||||
BoardModelVisibilitySet(BoardStarMdlGet(), 1);
|
||||
BoardModelRotYSet(StarPlatGetMdl(), rot.y);
|
||||
BoardModelVisibilitySet(StarPlatGetMdl(), 1);
|
||||
}
|
||||
|
||||
s32 BoardSpaceStarGetNext(void)
|
||||
|
|
@ -550,8 +573,8 @@ void BoardSpaceLandExec(s32 player, s32 space)
|
|||
if(_CheckFlag(FLAG_ID_MAKE(1, 11))) {
|
||||
HuAudFXPlay(842);
|
||||
BoardCameraViewSet(2);
|
||||
BoardPlayerAnimBlendSet(player, 0, 15);
|
||||
while(!BoardPlayerAnimBlendCheck(player)) {
|
||||
BoardPlayerMotBlendSet(player, 0, 15);
|
||||
while(!BoardPlayerMotBlendCheck(player)) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
BoardCameraMotionWait();
|
||||
|
|
@ -586,4 +609,492 @@ void BoardSpaceLandExec(s32 player, s32 space)
|
|||
BoardStarExec(player, space);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
s32 BoardSpaceWalkExec(s32 player, s32 space)
|
||||
{
|
||||
s32 is_star;
|
||||
BoardSpace *space_ptr;
|
||||
BoardSpace *star_space;
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 11))) {
|
||||
space_ptr = BoardSpaceGet(0, space);
|
||||
if(space_ptr->flag & 0x180000) {
|
||||
BoardTutorialHookExec(25, 0);
|
||||
}
|
||||
}
|
||||
if(BoardPlayerSizeGet(player) == 2 || GWPlayer[player].bowser_suit) {
|
||||
return 0;
|
||||
}
|
||||
space_ptr = BoardSpaceGet(0, space);
|
||||
if(BoardCurrGet() == 7 || BoardCurrGet() == 8) {
|
||||
is_star = 0;
|
||||
} else {
|
||||
star_space = BoardSpaceGet(0, boardSpaceStarTbl[GWSystem.star_pos]);
|
||||
if(space_ptr == star_space) {
|
||||
is_star = 1;
|
||||
} else {
|
||||
is_star = 0;
|
||||
}
|
||||
}
|
||||
if(is_star) {
|
||||
BoardStarExec(player, space);
|
||||
return 1;
|
||||
}
|
||||
if(space_ptr->flag & 0x600000) {
|
||||
u16 mg_param = GWSystem.unk_38;
|
||||
if(BoardPlayerSizeGet(player) == 1) {
|
||||
BoardRotateDiceNumbers(player);
|
||||
BoardMGCreate(mg_param);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
if(space_ptr->flag & 0x180000) {
|
||||
BoardShopExec(player, space);
|
||||
return 1;
|
||||
}
|
||||
if(space_ptr->flag & 0x08000000) {
|
||||
BoardBooHouseExec(player, space);
|
||||
return 1;
|
||||
}
|
||||
if(space_ptr->flag & 0x10000000) {
|
||||
BoardLotteryExec();
|
||||
return 1;
|
||||
}
|
||||
if(space_ptr->flag & 0x20000000) {
|
||||
ExecPipeSpace(player, space);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
s32 BoardSpaceBlockExec(s32 player, s32 space)
|
||||
{
|
||||
s32 event_exec;
|
||||
BoardSpace *space_ptr;
|
||||
event_exec = 0;
|
||||
if(BoardPlayerSizeGet(player) == 2 || GWPlayer[player].bowser_suit) {
|
||||
return 0;
|
||||
}
|
||||
space_ptr = BoardSpaceGet(0, space);
|
||||
event_exec = 0;
|
||||
if(space == GWSystem.block_pos) {
|
||||
event_exec = 1;
|
||||
}
|
||||
if((int)GWSystem.bonus_star == 0 && BoardPartyFlagGet() == 1 && !_CheckFlag(FLAG_ID_MAKE(1, 11))) {
|
||||
event_exec = 0;
|
||||
}
|
||||
if(BoardCurrGet() == 7 || BoardCurrGet() == 8) {
|
||||
event_exec = 0;
|
||||
}
|
||||
if(event_exec) {
|
||||
BoardBlockExec(player, space);
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 11))) {
|
||||
BoardBlockExec(player, space);
|
||||
}
|
||||
BoardSpaceBlockPosSet();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static s32 ExecPipeSpace(s32 player, s32 space)
|
||||
{
|
||||
Vec pos_link;
|
||||
Vec pos;
|
||||
Vec dir;
|
||||
float radius, y_vel;
|
||||
s32 mot_disable;
|
||||
BoardSpace *space_ptr;
|
||||
mot_disable = 0;
|
||||
if(BoardPlayerSizeGet(player) != 1) {
|
||||
return 0;
|
||||
}
|
||||
BoardPlayerPosGet(player, &pos);
|
||||
pos.y += 200.0f;
|
||||
space_ptr = BoardSpaceGet(0, space);
|
||||
BoardSpacePosGet(0, space_ptr->link[0], &pos_link);
|
||||
VECSubtract(&pos_link, &pos, &dir);
|
||||
VECNormalize(&dir, &dir);
|
||||
BoardPlayerRotYSet(player, 90-((atan2(dir.z, dir.x)/M_PI)*180));
|
||||
radius = 0.75f*BoardVecDistXZCalc(&pos_link, &pos);
|
||||
BoardPlayerMotionStart(player, 4, 0);
|
||||
y_vel = 0;
|
||||
while(1) {
|
||||
if(BoardVecDistXZCalc(&pos_link, &pos) < 2) {
|
||||
break;
|
||||
}
|
||||
pos.x += (dir.x*radius)/60.0f;
|
||||
pos.z += (dir.z*radius)/60.0f;
|
||||
if(pos.y <= pos_link.y) {
|
||||
pos.y = pos_link.y;
|
||||
if(!mot_disable) {
|
||||
BoardPlayerMotionShiftSet(player, 3, 0, 4, 0x40000001);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
pos.y += 10.0f+(-((1/2399.99f)+(1/50.0f))*y_vel*y_vel);
|
||||
y_vel += 1.0f;
|
||||
}
|
||||
BoardPlayerPosSetV(player, &pos);
|
||||
HuPrcVSleep();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void BoardSpaceTypeForce(u16 from, u16 to)
|
||||
{
|
||||
s32 i;
|
||||
for(i=0; i<spaceCnt[0]; i++) {
|
||||
BoardSpace *space = &spaceData[0][i];
|
||||
if(space->type == from) {
|
||||
space->type = to;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void BoardSpaceHide(s32 value)
|
||||
{
|
||||
if(value) {
|
||||
Hu3DModelAttrSet(spaceDrawMdl, 1);
|
||||
} else {
|
||||
Hu3DModelAttrReset(spaceDrawMdl, 1);
|
||||
}
|
||||
}
|
||||
|
||||
//Some stack allocation issues. code around BoardPlayerGetCurr is incorrect too
|
||||
static void DrawSpaces(ModelData *model, Mtx matrix)
|
||||
{
|
||||
s32 i;
|
||||
|
||||
Vec player_pos;
|
||||
Vec target;
|
||||
Vec pos;
|
||||
|
||||
Mtx lookat, final, rot_x, rot_y, rot_z, scale;
|
||||
Mtx44 proj;
|
||||
BoardCameraData *camera;
|
||||
if(!spaceDrawF) {
|
||||
return;
|
||||
}
|
||||
spaceDrawCnt = 0;
|
||||
camera = &boardCamera;
|
||||
BoardCameraPosGet(&pos);
|
||||
BoardCameraTargetGet(&target);
|
||||
MTXPerspective(proj, camera->fov, camera->aspect, camera->near, camera->far);
|
||||
GXSetProjection(proj, GX_PERSPECTIVE);
|
||||
MTXLookAt(lookat, &pos, &camera->up, &target);
|
||||
GXSetViewport(camera->viewport_x, camera->viewport_y, camera->viewport_w, camera->viewport_h, camera->viewport_near, camera->viewport_far);
|
||||
GXSetScissor(camera->viewport_x, camera->viewport_y, camera->viewport_w, camera->viewport_h);
|
||||
{
|
||||
GXColor color = { 0xFF, 0xFF, 0xFF, 0xFF };
|
||||
BoardSpace *space_curr;
|
||||
BoardSpace *space_hilite;
|
||||
PlayerState *player;
|
||||
PlayerState *player_temp;
|
||||
s16 player_mdl;
|
||||
float y_dist;
|
||||
s32 space_img;
|
||||
u16 space_type;
|
||||
float uv_x, uv_y, uv_size;
|
||||
|
||||
GXClearVtxDesc();
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
|
||||
GXInvalidateTexAll();
|
||||
GXLoadTexObj(&spaceTex, GX_TEXMAP0);
|
||||
GXSetNumTexGens(1);
|
||||
GXSetNumTevStages(1);
|
||||
GXSetTevColor(GX_TEVREG0, color);
|
||||
GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
|
||||
GXSetNumChans(1);
|
||||
GXSetChanAmbColor(GX_COLOR0A0, color);
|
||||
GXSetChanMatColor(GX_COLOR0A0, color);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
|
||||
GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_REG, GX_SRC_REG, 1, GX_DF_CLAMP, GX_AF_SPOT);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
|
||||
GXSetAlphaCompare(GX_GEQUAL, 1, GX_AOP_AND, GX_GEQUAL, 1);
|
||||
GXSetCullMode(GX_CULL_BACK);
|
||||
player = player_temp = BoardPlayerGetCurr();
|
||||
BoardPlayerPosGet(GWSystem.player_curr, &player_pos);
|
||||
player_mdl = BoardModelIDGet(BoardPlayerModelGetCurr());
|
||||
space_curr = &spaceData[0][0];
|
||||
space_hilite = NULL;
|
||||
GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
|
||||
for(i=0; i<spaceCnt[0]; i++, space_curr++) {
|
||||
if(space_curr->type == 0) {
|
||||
continue;
|
||||
}
|
||||
if(!BoardCameraCullCheck(&space_curr->pos, 200.0f) || (space_curr->flag & spaceAttr[0])) {
|
||||
continue;
|
||||
}
|
||||
if(!space_hilite) {
|
||||
if(player_pos.x > space_curr->pos.x-100.0f
|
||||
&& player_pos.z > space_curr->pos.z-100.0f
|
||||
&& player_pos.x < space_curr->pos.x+100.0f
|
||||
&& player_pos.z < space_curr->pos.z+100.0f) {
|
||||
if(player_pos.y-space_curr->pos.y < 0.0f) {
|
||||
y_dist = -(player_pos.y-space_curr->pos.y);
|
||||
} else {
|
||||
y_dist = player_pos.y-space_curr->pos.y;
|
||||
}
|
||||
if(y_dist < 10.0f) {
|
||||
space_hilite = space_curr;
|
||||
}
|
||||
}
|
||||
}
|
||||
space_type = space_curr->type;
|
||||
space_img = spaceImgIdx[space_type]-1;
|
||||
uv_x = (float)(space_img%4)/4.0f;
|
||||
uv_y = (float)(space_img/4)/4.0f;
|
||||
uv_size = 63.0f/256.0f;
|
||||
MTXRotRad(rot_z, 'z', MTXDegToRad(space_curr->rot.y));
|
||||
MTXRotRad(rot_y, 'y', MTXDegToRad(space_curr->rot.z));
|
||||
MTXRotRad(rot_x, 'x', MTXDegToRad(space_curr->rot.x+90.0f));
|
||||
MTXTrans(final, space_curr->pos.x, 3.0f+space_curr->pos.y, space_curr->pos.z);
|
||||
MTXConcat(rot_x, rot_y, rot_y);
|
||||
MTXConcat(rot_y, rot_z, rot_z);
|
||||
MTXConcat(final, rot_z, final);
|
||||
MTXConcat(lookat, final, final);
|
||||
GXLoadPosMtxImm(final, GX_PNMTX0);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
GXPosition3f32(-100, -100, 0);
|
||||
GXTexCoord2f32(uv_x, uv_y);
|
||||
GXPosition3f32(100, -100, 0);
|
||||
GXTexCoord2f32(uv_x+uv_size, uv_y);
|
||||
GXPosition3f32(100, 100, 0);
|
||||
GXTexCoord2f32(uv_x+uv_size, uv_y+uv_size+(1.5f/256.0f));
|
||||
GXPosition3f32(-100, 100, 0);
|
||||
GXTexCoord2f32(uv_x, uv_y+uv_size+(1.5f/256.0f));
|
||||
GXEnd();
|
||||
spaceDrawCnt++;
|
||||
}
|
||||
if(space_hilite) {
|
||||
space_curr = space_hilite;
|
||||
space_type = space_curr->type;
|
||||
if(player->show_next && space_type != 0 && (space_img = spaceHiliteImgIdx[space_type]) >= 0) {
|
||||
GXSetZMode(GX_TRUE, GX_LEQUAL, GX_FALSE);
|
||||
GXLoadTexObj(&spaceHiliteTex, GX_TEXMAP0);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_NOOP);
|
||||
uv_x = (float)(space_img%4)/4.0f;
|
||||
uv_y = (float)(space_img/4)/4.0f;
|
||||
uv_size = 63.0f/256.0f;
|
||||
MTXScale(scale, 1.5f, 1.5f, 1.5f);
|
||||
MTXRotRad(rot_z, 'z', MTXDegToRad(space_curr->rot.y));
|
||||
MTXRotRad(rot_y, 'y', MTXDegToRad(space_curr->rot.z));
|
||||
MTXRotRad(rot_x, 'x', MTXDegToRad(space_curr->rot.x+90.0f));
|
||||
MTXTrans(final, space_curr->pos.x, 3.5f+space_curr->pos.y, space_curr->pos.z);
|
||||
MTXConcat(scale, rot_x, rot_x);
|
||||
MTXConcat(rot_x, rot_y, rot_y);
|
||||
MTXConcat(rot_y, rot_z, rot_z);
|
||||
MTXConcat(final, rot_z, final);
|
||||
MTXConcat(lookat, final, final);
|
||||
GXLoadPosMtxImm(final, GX_PNMTX0);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
GXPosition3f32(-100, -100, 0);
|
||||
GXTexCoord2f32(uv_x, uv_y);
|
||||
GXPosition3f32(100, -100, 0);
|
||||
GXTexCoord2f32(uv_x+uv_size, uv_y);
|
||||
GXPosition3f32(100, 100, 0);
|
||||
GXTexCoord2f32(uv_x+uv_size, uv_y+uv_size);
|
||||
GXPosition3f32(-100, 100, 0);
|
||||
GXTexCoord2f32(uv_x, uv_y+uv_size);
|
||||
GXEnd();
|
||||
spaceDrawCnt++;
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
|
||||
GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
|
||||
return;
|
||||
}
|
||||
}
|
||||
GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
s32 BoardSpaceRead(s32 layer, s32 data_num)
|
||||
{
|
||||
int j;
|
||||
int i;
|
||||
BoardSpace *space;
|
||||
u8 *data;
|
||||
s32 star_idx;
|
||||
u8 *data_base;
|
||||
data_base = data = HuDataSelHeapReadNum(data_num, MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
spaceCnt[layer] = *(u32 *)data;
|
||||
data += sizeof(u32);
|
||||
space = &spaceData[layer][0];
|
||||
for(i=0; i<spaceCnt[layer]; i++, space++) {
|
||||
memcpy(&space->pos, data, sizeof(Vec));
|
||||
data += sizeof(Vec);
|
||||
memcpy(&space->rot, data, sizeof(Vec));
|
||||
data += sizeof(Vec);
|
||||
memcpy(&space->scale, data, sizeof(Vec));
|
||||
data += sizeof(Vec);
|
||||
space->flag = *(u32 *)data;
|
||||
data += sizeof(u32);
|
||||
space->type = *(u16 *)data;
|
||||
data += sizeof(u16);
|
||||
space->link_cnt = *(u16 *)data;
|
||||
data += sizeof(u16);
|
||||
for(j=0; j<space->link_cnt; j++) {
|
||||
space->link[j] = (*(u16 *)data)+1;
|
||||
data += sizeof(u16);
|
||||
}
|
||||
if(space->type == 8) {
|
||||
|
||||
space->type = 1;
|
||||
star_idx = (space->flag & 0x70000) >> 16;
|
||||
boardSpaceStarTbl[star_idx] = i+1;
|
||||
}
|
||||
}
|
||||
HuDataClose(data_base);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void BoardSpaceCameraSet(u16 mask)
|
||||
{
|
||||
Hu3DModelCameraSet(spaceDrawMdl, mask);
|
||||
}
|
||||
|
||||
void BoardSpaceBlockPosSet(void)
|
||||
{
|
||||
BoardSpace *space;
|
||||
s32 block_pos;
|
||||
begin:
|
||||
if(boardTutorialBlockF) {
|
||||
GWSystem.block_pos = boardTutorialBlockPos;
|
||||
return;
|
||||
}
|
||||
block_pos = BoardRandMod(spaceCnt[0])+1;
|
||||
if(block_pos == GWSystem.block_pos) {
|
||||
goto begin;
|
||||
}
|
||||
space = BoardSpaceGet(0, block_pos);
|
||||
if(space->type != 1) {
|
||||
goto begin;
|
||||
}
|
||||
GWSystem.block_pos = block_pos;
|
||||
}
|
||||
|
||||
void BoardSpaceInit(s32 data_num)
|
||||
{
|
||||
s32 board;
|
||||
BoardJunctionMaskZero();
|
||||
memset(spaceData, 0, sizeof(spaceData));
|
||||
memset(spaceAttr, 0, sizeof(spaceAttr));
|
||||
lbl_801D3FC4[0] = lbl_801D3FC4[1] = lbl_801D3FC4[2] = lbl_801D3FC4[3] = -1;
|
||||
spaceDrawF = 0;
|
||||
board = BoardCurrGet();
|
||||
{
|
||||
AnimBmpData *bmp;
|
||||
AnimData *data;
|
||||
void *data_base;
|
||||
s32 size;
|
||||
data = data_base = HuDataSelHeapReadNum(MAKE_DATA_NUM(DATADIR_BOARD, 29), MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
data->bmp = (void *)((u32)data_base+(u32)data->bmp);
|
||||
data->pat = (void *)((u32)data_base+(u32)data->pat);
|
||||
data->bank = (void *)((u32)data_base+(u32)data->bank);
|
||||
bmp = data->bmp;
|
||||
size = bmp->sizeX;
|
||||
spaceHiliteTexFmt = -1;
|
||||
switch(bmp->dataFmt) {
|
||||
case SPRITE_BMP_RGBA8:
|
||||
spaceHiliteTexFmt = GX_TF_RGBA8;
|
||||
break;
|
||||
|
||||
case SPRITE_BMP_RGB5A3_DUPE:
|
||||
spaceHiliteTexFmt = GX_TF_RGB5A3;
|
||||
break;
|
||||
|
||||
case SPRITE_BMP_CMPR:
|
||||
spaceHiliteTexFmt = GX_TF_CMPR;
|
||||
break;
|
||||
}
|
||||
spaceHiliteTexData = HuMemDirectMallocNum(HEAP_SYSTEM, bmp->dataSize, MEMORY_DEFAULT_NUM);
|
||||
bmp->data = (void *)((u32)bmp->data+(u32)data_base);
|
||||
memcpy(spaceHiliteTexData, bmp->data, bmp->dataSize);
|
||||
HuDataClose(data_base);
|
||||
GXInitTexObj(&spaceHiliteTex, spaceHiliteTexData, size, size, spaceHiliteTexFmt, GX_CLAMP, GX_CLAMP, GX_FALSE);
|
||||
GXInitTexObjLOD(&spaceHiliteTex, GX_LINEAR, GX_LINEAR, 0, 0, 0, GX_FALSE, GX_FALSE, GX_ANISO_1);
|
||||
}
|
||||
{
|
||||
AnimBmpData *bmp;
|
||||
AnimData *data;
|
||||
void *data_base;
|
||||
s32 size;
|
||||
data = data_base = HuDataSelHeapReadNum(MAKE_DATA_NUM(DATADIR_BOARD, 28), MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
data->bmp = (void *)((u32)data_base+(u32)data->bmp);
|
||||
data->pat = (void *)((u32)data_base+(u32)data->pat);
|
||||
data->bank = (void *)((u32)data_base+(u32)data->bank);
|
||||
bmp = data->bmp;
|
||||
size = bmp->sizeX;
|
||||
spaceTexFmt = -1;
|
||||
switch(bmp->dataFmt) {
|
||||
case SPRITE_BMP_RGBA8:
|
||||
spaceTexFmt = GX_TF_RGBA8;
|
||||
break;
|
||||
|
||||
case SPRITE_BMP_RGB5A3_DUPE:
|
||||
spaceTexFmt = GX_TF_RGB5A3;
|
||||
break;
|
||||
|
||||
case SPRITE_BMP_CMPR:
|
||||
spaceTexFmt = GX_TF_CMPR;
|
||||
break;
|
||||
}
|
||||
spaceTexData = HuMemDirectMallocNum(HEAP_SYSTEM, bmp->dataSize, MEMORY_DEFAULT_NUM);
|
||||
bmp->data = (void *)((u32)bmp->data+(u32)data_base);
|
||||
memcpy(spaceTexData, bmp->data, bmp->dataSize);
|
||||
HuDataClose(data_base);
|
||||
GXInitTexObj(&spaceTex, spaceTexData, size, size, spaceTexFmt, GX_CLAMP, GX_CLAMP, GX_FALSE);
|
||||
GXInitTexObjLOD(&spaceTex, GX_LINEAR, GX_LINEAR, 0, 0, 0, GX_FALSE, GX_FALSE, GX_ANISO_1);
|
||||
}
|
||||
BoardSpaceRead(0, data_num);
|
||||
spaceDrawMdl = Hu3DHookFuncCreate(DrawSpaces);
|
||||
if(!BoardStartCheck() && !_CheckFlag(FLAG_ID_MAKE(1, 1))) {
|
||||
BoardSpaceBlockPosSet();
|
||||
GWSystem.star_total = 0;
|
||||
GWSystem.star_flag = 0;
|
||||
}
|
||||
if(BoardCurrGet() != 7 && BoardCurrGet() != 8) {
|
||||
starPlatMdl = BoardModelCreate(MAKE_DATA_NUM(DATADIR_BOARD, 6), NULL, 0);
|
||||
BoardModelMotionStart(starPlatMdl, 0, 0x40000001);
|
||||
BoardModelVisibilitySet(starPlatMdl, 0);
|
||||
if(_CheckFlag(FLAG_ID_MAKE(1, 1))) {
|
||||
Vec pos;
|
||||
Vec rot;
|
||||
s16 space;
|
||||
BoardModelVisibilitySet(starPlatMdl, 1);
|
||||
GWSystem.star_flag |= (u8)(1 << GWSystem.star_pos);
|
||||
BoardSpaceTypeSet(0, boardSpaceStarTbl[GWSystem.star_pos], 8);
|
||||
{
|
||||
int space;
|
||||
BoardSpace *space_plat;
|
||||
space = BoardSpaceLinkFlagSearch(0, BoardSpaceStarGetCurr(), 0x04000000);
|
||||
BoardSpacePosGet(0, space, &pos);
|
||||
BoardModelPosSetV(StarPlatGetMdl(), &pos);
|
||||
BoardSpaceRotGet(0, space, &rot);
|
||||
BoardModelRotYSet(StarPlatGetMdl(), rot.y);
|
||||
}
|
||||
}
|
||||
}
|
||||
spaceDrawF = 1;
|
||||
}
|
||||
|
||||
void BoardSpaceDestroy(void)
|
||||
{
|
||||
if(spaceDrawMdl >= 0) {
|
||||
Hu3DModelKill(spaceDrawMdl);
|
||||
spaceDrawMdl = -1;
|
||||
}
|
||||
if(spaceHiliteTexData) {
|
||||
HuMemDirectFree(spaceHiliteTexData);
|
||||
spaceHiliteTexData = NULL;
|
||||
}
|
||||
if(spaceTexData) {
|
||||
HuMemDirectFree(spaceTexData);
|
||||
spaceTexData = NULL;
|
||||
}
|
||||
}
|
||||
|
|
@ -3,8 +3,8 @@
|
|||
#include "game/board/player.h"
|
||||
#include "game/wipe.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "game/hsfex.h"
|
||||
#include "board_unsplit.h"
|
||||
#include "unsplit.h"
|
||||
#include "math.h"
|
||||
|
||||
static void WarpInit(s32);
|
||||
|
|
@ -15,10 +15,10 @@ static void WarpImpact(s32);
|
|||
|
||||
|
||||
extern void omVibrate(s16, s16, s16, s16);
|
||||
extern void fn_800816CC(s32, s32);
|
||||
extern void fn_80081884(f32);
|
||||
extern void fn_8008181C(void);
|
||||
extern s32 fn_8008186C(void);
|
||||
extern void BoardCharWheelInit(s32, s32);
|
||||
extern void BoardCharWheelSpeedSet(f32);
|
||||
extern void BoardCharWheelWait(void);
|
||||
extern s32 BoardCharWheelResultGet(void);
|
||||
extern f32 BoardModelMotionTimeGet(s16);
|
||||
extern void BoardModelHookReset(s16);
|
||||
extern s32 BoardModelHookSet(s16, char*, s16);
|
||||
|
|
@ -46,7 +46,7 @@ static s8 warpImpactPlayer[4] = {-1, -1, -1, -1};
|
|||
static void WarpProcess(void);
|
||||
static void WarpKill(void);
|
||||
|
||||
void BoardWarpExec(s32 player, s16 space) {
|
||||
void BoardWarpExec(s32 player, s32 space) {
|
||||
omVibrate(player, 12, 4, 2);
|
||||
warpProcess = HuPrcChildCreate(WarpProcess, 8195, 14336, 0, boardMainProc);
|
||||
HuPrcDestructorSet2(warpProcess, WarpKill);
|
||||
|
|
@ -66,9 +66,9 @@ void WarpProcess(void) {
|
|||
HuAudFXPlay(842);
|
||||
BoardCameraViewSet(3);
|
||||
BoardCameraMotionWait();
|
||||
BoardPlayerAnimBlendSet(curr_player, 0, 15);
|
||||
BoardPlayerMotBlendSet(curr_player, 0, 15);
|
||||
|
||||
while (BoardPlayerAnimBlendCheck(curr_player) == 0) {
|
||||
while (BoardPlayerMotBlendCheck(curr_player) == 0) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
|
||||
|
|
@ -77,10 +77,10 @@ void WarpProcess(void) {
|
|||
BoardTutorialHookExec(18, 0);
|
||||
boardTutorialData[0] = 0;
|
||||
}
|
||||
fn_800816CC(curr_player, 3);
|
||||
fn_80081884(18.0f);
|
||||
fn_8008181C();
|
||||
warpTarget = fn_8008186C();
|
||||
BoardCharWheelInit(curr_player, 3);
|
||||
BoardCharWheelSpeedSet(18.0f);
|
||||
BoardCharWheelWait();
|
||||
warpTarget = BoardCharWheelResultGet();
|
||||
BoardCameraViewSet(1);
|
||||
BoardCameraMotionWait();
|
||||
WarpInit(curr_player);
|
||||
|
|
@ -232,7 +232,7 @@ static void WarpImpact(s32 player) {
|
|||
BoardModelMotionStart(warpImpactMdl, 0, 0x40000001);
|
||||
|
||||
for (i = 0; i < warpImpactCnt; i++) {
|
||||
s32 player = warpImpactPlayer[i];
|
||||
s16 player = warpImpactPlayer[i];
|
||||
omVibrate(player, 0xC, 4, 2);
|
||||
BoardPlayerMotionStart(player, 6, 0x40000001);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -182,7 +182,6 @@ void BoardWinPause(void) {
|
|||
|
||||
void BoardWinCreateChoice(s32 pos, u32 mess, s32 portrait, s32 choice) {
|
||||
s32 i;
|
||||
s32 speed;
|
||||
|
||||
|
||||
winPosIdx = pos;
|
||||
|
|
@ -213,13 +212,11 @@ void BoardWinCreateChoice(s32 pos, u32 mess, s32 portrait, s32 choice) {
|
|||
if (GWSystem.mess_speed == 3) {
|
||||
GWSystem.mess_speed = 1;
|
||||
}
|
||||
speed = GWSystem.mess_speed;
|
||||
BoardWinSpeedSet(speed);
|
||||
BoardWinSpeedSet(GWMessSpeedGet());
|
||||
BoardWinPlayerSet(GWSystem.player_curr);
|
||||
}
|
||||
|
||||
void BoardWinCreate(s32 pos, u32 mess, s32 portrait) {
|
||||
s32 speed;
|
||||
s32 i;
|
||||
|
||||
winPosIdx = pos;
|
||||
|
|
@ -250,8 +247,7 @@ void BoardWinCreate(s32 pos, u32 mess, s32 portrait) {
|
|||
if (GWSystem.mess_speed == 3) {
|
||||
GWSystem.mess_speed = 1;
|
||||
}
|
||||
speed = GWSystem.mess_speed;
|
||||
BoardWinSpeedSet(speed);
|
||||
BoardWinSpeedSet(GWMessSpeedGet());
|
||||
BoardWinPlayerSet(GWSystem.player_curr);
|
||||
autoPickF = 0;
|
||||
}
|
||||
|
|
@ -281,14 +277,14 @@ void BoardWinKill(void) {
|
|||
}
|
||||
}
|
||||
|
||||
void BoardWinSetAttr(s32 attr) {
|
||||
void BoardWinAttrSet(s32 attr) {
|
||||
winAttr |= attr;
|
||||
if (windowID >= 0) {
|
||||
HuWinAttrSet(windowID, winAttr);
|
||||
}
|
||||
}
|
||||
|
||||
void BoardWinResetAttr(s32 attr) {
|
||||
void BoardWinAttrReset(s32 attr) {
|
||||
winAttr &= ~attr;
|
||||
if (windowID >= 0) {
|
||||
HuWinAttrSet(windowID, winAttr);
|
||||
|
|
@ -381,7 +377,7 @@ void BoardWinPlayerSet(s32 player) {
|
|||
|
||||
void BoardWinStartComKeySet(void) {
|
||||
s32 comkey[4];
|
||||
s32 speed;
|
||||
s32 delay;
|
||||
s32 waitnum;
|
||||
s32 i;
|
||||
|
||||
|
|
@ -410,12 +406,12 @@ void BoardWinStartComKeySet(void) {
|
|||
}
|
||||
}
|
||||
}
|
||||
speed = GWMessSpeedGet();
|
||||
delay = GWMessDelayGet();
|
||||
waitnum = HuWinKeyWaitNumGet(winMess);
|
||||
if (waitnum != 0) {
|
||||
HuWinComKeyReset();
|
||||
for (i = 0; i < waitnum; i++) {
|
||||
HuWinComKeyWait(comkey[0], comkey[1], comkey[2], comkey[3], speed);
|
||||
HuWinComKeyWait(comkey[0], comkey[1], comkey[2], comkey[3], delay);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
145
src/game/esprite.c
Executable file
145
src/game/esprite.c
Executable file
|
|
@ -0,0 +1,145 @@
|
|||
#include "game/esprite.h"
|
||||
#include "game/data.h"
|
||||
#include "game/sprite.h"
|
||||
|
||||
typedef struct {
|
||||
/* 0x00 */ u32 unk00;
|
||||
/* 0x04 */ u16 unk04;
|
||||
/* 0x06 */ char unk06[2];
|
||||
/* 0x08 */ AnimData *unk08;
|
||||
} UnkEspriteStruct01; // Size 0xC
|
||||
|
||||
s16 esprite[0x180][2];
|
||||
UnkEspriteStruct01 espanim[0x180];
|
||||
|
||||
static s16 gid;
|
||||
|
||||
void espInit(void) {
|
||||
s32 i;
|
||||
|
||||
gid = HuSprGrpCreate(0x180);
|
||||
for (i = 0; i < 0x180; i++) {
|
||||
esprite[i][0] = i;
|
||||
esprite[i][1] = -1;
|
||||
}
|
||||
for (i = 0; i < 0x180; i++) {
|
||||
espanim[i].unk04 = 0;
|
||||
}
|
||||
}
|
||||
|
||||
s16 espEntry(s32 arg0, s16 arg1, s16 arg2) {
|
||||
UnkEspriteStruct01 *var_r30;
|
||||
UnkEspriteStruct01 *var_r31;
|
||||
s16 (*var_r29)[2];
|
||||
void *temp_r26;
|
||||
s16 temp_r25;
|
||||
s16 var_r28;
|
||||
s32 var_r27;
|
||||
|
||||
var_r29 = esprite;
|
||||
for (var_r28 = 0; var_r28 < 0x180; var_r29++, var_r28++) {
|
||||
if (var_r29[0][1] == -1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (var_r28 == 0x180) {
|
||||
return -1;
|
||||
}
|
||||
var_r31 = espanim;
|
||||
var_r30 = NULL;
|
||||
for (var_r27 = 0; var_r27 < 0x180; var_r31++, var_r27++) {
|
||||
if (var_r31->unk04 != 0) {
|
||||
if (var_r31->unk00 == arg0) {
|
||||
var_r30 = NULL;
|
||||
break;
|
||||
}
|
||||
} else if (var_r30 == NULL) {
|
||||
var_r30 = var_r31;
|
||||
}
|
||||
}
|
||||
if (var_r27 == 0x180) {
|
||||
if (var_r30 == NULL) {
|
||||
return -1;
|
||||
}
|
||||
temp_r26 = HuDataSelHeapReadNum(arg0, MEMORY_DEFAULT_NUM, HEAP_DATA);
|
||||
if (temp_r26 == NULL) {
|
||||
return -1;
|
||||
}
|
||||
var_r30->unk00 = arg0;
|
||||
var_r30->unk08 = HuSprAnimRead(temp_r26);
|
||||
var_r31 = var_r30;
|
||||
}
|
||||
temp_r25 = HuSprCreate(var_r31->unk08, arg1, arg2);
|
||||
if (temp_r25 == -1) {
|
||||
if (var_r30 != NULL) {
|
||||
HuSprAnimKill(var_r31->unk08);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
var_r31->unk04++;
|
||||
var_r29[0][1] = var_r31 - espanim;
|
||||
HuSprGrpMemberSet(gid, var_r29[0][0], temp_r25);
|
||||
return var_r28;
|
||||
}
|
||||
|
||||
void espKill(s16 arg0) {
|
||||
HuSprGrpMemberKill(gid, esprite[arg0][0]);
|
||||
espanim[esprite[arg0][1]].unk04--;
|
||||
esprite[arg0][1] = -1;
|
||||
}
|
||||
|
||||
s16 espGrpIDGet(void) {
|
||||
return gid;
|
||||
}
|
||||
|
||||
void espDispOn(s16 arg0) {
|
||||
HuSprAttrReset(gid, esprite[arg0][0], 4);
|
||||
}
|
||||
|
||||
void espDispOff(s16 arg0) {
|
||||
HuSprAttrSet(gid, esprite[arg0][0], 4);
|
||||
}
|
||||
|
||||
void espAttrSet(s16 arg0, u16 arg1) {
|
||||
HuSprAttrSet(gid, esprite[arg0][0], arg1);
|
||||
}
|
||||
|
||||
void espAttrReset(s16 arg0, u16 arg1) {
|
||||
HuSprAttrReset(gid, esprite[arg0][0], arg1);
|
||||
}
|
||||
|
||||
void espPosSet(s16 arg0, float arg1, float arg2) {
|
||||
HuSprPosSet(gid, esprite[arg0][0], arg1, arg2);
|
||||
}
|
||||
|
||||
void espScaleSet(s16 arg0, float arg1, float arg2) {
|
||||
HuSprScaleSet(gid, esprite[arg0][0], arg1, arg2);
|
||||
}
|
||||
|
||||
void espZRotSet(s16 arg0, float arg1) {
|
||||
HuSprZRotSet(gid, esprite[arg0][0], arg1);
|
||||
}
|
||||
|
||||
void espTPLvlSet(s16 arg0, float arg1) {
|
||||
HuSprTPLvlSet(gid, esprite[arg0][0], arg1);
|
||||
}
|
||||
|
||||
void espColorSet(s16 arg0, u8 arg1, u8 arg2, u8 arg3) {
|
||||
HuSprColorSet(gid, esprite[arg0][0], arg1, arg2, arg3);
|
||||
}
|
||||
|
||||
void espSpeedSet(s16 arg0, float arg1) {
|
||||
HuSprSpeedSet(gid, esprite[arg0][0], arg1);
|
||||
}
|
||||
|
||||
void espBankSet(s16 arg0, s16 arg1) {
|
||||
HuSprBankSet(gid, esprite[arg0][0], arg1);
|
||||
}
|
||||
|
||||
void espDrawNoSet(s16 arg0, s16 arg1) {
|
||||
HuSprDrawNoSet(gid, esprite[arg0][0], arg1);
|
||||
}
|
||||
|
||||
void espPriSet(s16 arg0, s16 arg1) {
|
||||
HuSprPriSet(gid, esprite[arg0][0], arg1);
|
||||
}
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
#include "common.h"
|
||||
#include "game/gamework_data.h"
|
||||
#include "stdarg.h"
|
||||
#include "stdio.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -2,26 +2,25 @@
|
|||
|
||||
static u32 frand_seed;
|
||||
|
||||
static inline u32 frandom(void)
|
||||
static inline u32 frandom(u32 param)
|
||||
{
|
||||
u32 rand = frand_seed;
|
||||
s32 rand2, rand3;
|
||||
|
||||
if (rand == 0) {
|
||||
rand = rand8();
|
||||
rand = rand ^ (s64)OSGetTime();
|
||||
rand ^= 0xD826BC89;
|
||||
if (param == 0) {
|
||||
param = rand8();
|
||||
param = param ^ (s64)OSGetTime();
|
||||
param ^= 0xD826BC89;
|
||||
}
|
||||
|
||||
rand2 = rand / (u32)0x1F31D;
|
||||
rand3 = rand - (rand2 * 0x1F31D);
|
||||
rand = rand2 * 0xB14;
|
||||
rand = rand - rand3 * 0x41A7;
|
||||
return rand;
|
||||
rand2 = param / (u32)0x1F31D;
|
||||
rand3 = param - (rand2 * 0x1F31D);
|
||||
param = rand2 * 0xB14;
|
||||
param = param - rand3 * 0x41A7;
|
||||
return param;
|
||||
}
|
||||
|
||||
u32 frand(void) {
|
||||
return frand_seed = frandom();
|
||||
return frand_seed = frandom(frand_seed);
|
||||
}
|
||||
|
||||
f32 frandf(void) {
|
||||
|
|
@ -34,7 +33,7 @@ f32 frandf(void) {
|
|||
|
||||
u32 frandmod(u32 arg0) {
|
||||
u32 ret;
|
||||
frand_seed = frandom();
|
||||
frand_seed = frandom(frand_seed);
|
||||
ret = (frand_seed & 0x7FFFFFFF)%arg0;
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -134,7 +134,7 @@ void GWGameStatReset(void)
|
|||
ResetBoardSettings();
|
||||
}
|
||||
|
||||
s32 GWMessSpeedGet(void)
|
||||
s32 GWMessDelayGet(void)
|
||||
{
|
||||
if(GWSystem.mess_delay > 48) {
|
||||
GWSystem.mess_speed = 1;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
#include "game/hsfanim.h"
|
||||
#include "game/hsfdraw.h"
|
||||
#include "game/init.h"
|
||||
#include "game/memory.h"
|
||||
#include "game/process.h"
|
||||
|
||||
|
|
@ -34,13 +35,6 @@ Hu3DTexAnimDataStruct Hu3DTexAnimData[256];
|
|||
Hu3DTexScrDataStruct Hu3DTexScrData[16];
|
||||
static Process *parManProc[64];
|
||||
|
||||
// TODO: move to GXVert
|
||||
static inline void GXUnknownu16(const u16 x, const u16 y, const u16 z) {
|
||||
GXWGFifo.u16 = x;
|
||||
GXWGFifo.u16 = y;
|
||||
GXWGFifo.u16 = z;
|
||||
}
|
||||
|
||||
void Hu3DAnimInit(void) {
|
||||
Hu3DTexAnimDataStruct *var_r30;
|
||||
Hu3DTexScrDataStruct *var_r29;
|
||||
|
|
@ -536,10 +530,18 @@ s16 Hu3DParticleCreate(AnimData *arg0, s16 arg1) {
|
|||
GXBeginDisplayList(temp_r24, 0x20000);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, arg1 * 4);
|
||||
for (i = 0; i < arg1; i++) {
|
||||
GXUnknownu16(i * 4, i, 0);
|
||||
GXUnknownu16(i * 4 + 1, i, 1);
|
||||
GXUnknownu16(i * 4 + 2, i, 2);
|
||||
GXUnknownu16(i * 4 + 3, i, 3);
|
||||
GXPosition1x16(i*4);
|
||||
GXColor1x16(i);
|
||||
GXTexCoord1x16(0);
|
||||
GXPosition1x16((i*4)+1);
|
||||
GXColor1x16(i);
|
||||
GXTexCoord1x16(1);
|
||||
GXPosition1x16((i*4)+2);
|
||||
GXColor1x16(i);
|
||||
GXTexCoord1x16(2);
|
||||
GXPosition1x16((i*4)+3);
|
||||
GXColor1x16(i);
|
||||
GXTexCoord1x16(3);
|
||||
}
|
||||
temp_r31->unk_40 = GXEndDisplayList();
|
||||
return temp_r25;
|
||||
|
|
|
|||
|
|
@ -16,27 +16,6 @@ typedef struct {
|
|||
/* 0x3C */ Vec unk3C;
|
||||
} HsfdrawStruct00; // Size 0x48
|
||||
|
||||
typedef struct {
|
||||
/* 0x00 */ u16 unk00;
|
||||
/* 0x02 */ s16 unk02;
|
||||
/* 0x04 */ s16 unk04;
|
||||
/* 0x06 */ char unk06[2];
|
||||
/* 0x08 */ float unk08;
|
||||
/* 0x0C */ float unk0C;
|
||||
/* 0x10 */ float unk10;
|
||||
/* 0x14 */ float unk14;
|
||||
/* 0x18 */ float unk18;
|
||||
/* 0x1C */ float unk1C;
|
||||
/* 0x20 */ float unk20;
|
||||
/* 0x24 */ float unk24;
|
||||
/* 0x28 */ float unk28;
|
||||
/* 0x2C */ float unk2C;
|
||||
/* 0x30 */ float unk30;
|
||||
/* 0x34 */ float unk34;
|
||||
/* 0x38 */ float unk38;
|
||||
/* 0x3C */ HsfBitmap *unk3C;
|
||||
} HsfdrawStruct01; // Size unknown
|
||||
|
||||
typedef struct {
|
||||
s32 unk00;
|
||||
s32 unk04;
|
||||
|
|
|
|||
572
src/game/hsfex.c
Normal file
572
src/game/hsfex.c
Normal file
|
|
@ -0,0 +1,572 @@
|
|||
#include "game/hsfex.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/hsfmotion.h"
|
||||
|
||||
#include "math.h"
|
||||
|
||||
typedef struct {
|
||||
/* 0x00 */ float unk00;
|
||||
/* 0x04 */ float unk04;
|
||||
/* 0x08 */ Vec unk08;
|
||||
/* 0x14 */ Vec unk14;
|
||||
/* 0x20 */ Vec unk20;
|
||||
} HsfexStruct02; // Size 0x2C
|
||||
|
||||
static void SetObjCamMotion(s16 arg0, HsfTrack *arg1, float arg2, HsfexStruct02 *arg3);
|
||||
|
||||
void CamMotionEx2(s16 arg0, s16 arg1, float arg2, s16 arg3) {
|
||||
CameraData *temp_r30;
|
||||
s16 i;
|
||||
|
||||
for (i = 0; i < 16; i++) {
|
||||
if (arg1 & (1 << i)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
temp_r30 = &Hu3DCamera[i];
|
||||
CamMotionEx(arg0, arg1, &temp_r30->pos, &temp_r30->up, &temp_r30->target, arg2, arg3);
|
||||
}
|
||||
|
||||
void CamMotionEx(s16 arg0, s16 arg1, Vec *arg2, Vec *arg3, Vec *arg4, float arg5, s16 arg6) {
|
||||
Vec sp3C;
|
||||
float sp2C[4];
|
||||
float sp1C[4];
|
||||
float temp_f29;
|
||||
float var_f27;
|
||||
float var_f26;
|
||||
float var_f30;
|
||||
float var_f31;
|
||||
s16 sp1A;
|
||||
s16 var_r25;
|
||||
s16 var_r29;
|
||||
s16 var_r30;
|
||||
HsfexStruct02 *var_r31;
|
||||
CameraData *temp_r27;
|
||||
ModelData *temp_r23;
|
||||
HsfData *temp_r22;
|
||||
MotionData *temp_r19;
|
||||
HsfData *temp_r18;
|
||||
HsfObject *temp_r24;
|
||||
HsfTrack *temp_r20;
|
||||
HsfMotion *temp_r26;
|
||||
HsfexStruct02 *temp_r21;
|
||||
HsfTrack *var_r28;
|
||||
|
||||
temp_r23 = &Hu3DData[arg0];
|
||||
temp_r19 = &Hu3DMotion[temp_r23->unk_08];
|
||||
temp_r22 = temp_r23->hsfData;
|
||||
temp_r18 = temp_r19->unk_04;
|
||||
temp_r26 = temp_r18->motion;
|
||||
for (var_r25 = 0; var_r25 < 16; var_r25++) {
|
||||
if (arg1 & (1 << var_r25)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
temp_r27 = &Hu3DCamera[var_r25];
|
||||
temp_f29 = temp_r26->len;
|
||||
sp1A = 0.5f + (temp_f29 / 6.0f) + 1.0f;
|
||||
var_r31 = temp_r21 = HuMemDirectMallocNum(HEAP_SYSTEM, (sp1A + 1) * sizeof(HsfexStruct02), MEMORY_DEFAULT_NUM);
|
||||
var_r31->unk00 = 0.0f;
|
||||
var_r31->unk08 = *arg2;
|
||||
var_r31->unk20 = *arg4;
|
||||
var_r31->unk14 = *arg3;
|
||||
var_r31++;
|
||||
for (var_r29 = 1, var_f31 = 0.0f; var_f31 <= temp_f29; var_r31++, var_r29++) {
|
||||
var_r31->unk00 = var_f31;
|
||||
var_r28 = temp_r26->track;
|
||||
temp_r20 = &var_r28[temp_r26->numTracks];
|
||||
while (var_r28 < temp_r20) {
|
||||
if (var_r28->type == 2) {
|
||||
temp_r24 = &temp_r22->object[var_r28->target];
|
||||
if (temp_r24->type == 7) {
|
||||
SetObjCamMotion(arg0, var_r28, GetCurve(var_r28, var_f31), var_r31);
|
||||
}
|
||||
}
|
||||
var_r28++;
|
||||
}
|
||||
var_f31 += 6.0f;
|
||||
}
|
||||
if (var_f31 != temp_f29) {
|
||||
var_r31->unk00 = temp_f29;
|
||||
var_r28 = temp_r26->track;
|
||||
temp_r20 = &var_r28[temp_r26->numTracks];
|
||||
while (var_r28 < temp_r20) {
|
||||
if (var_r28->type == 2) {
|
||||
temp_r24 = &temp_r22->object[var_r28->target];
|
||||
if (temp_r24->type == 7) {
|
||||
SetObjCamMotion(arg0, var_r28, GetCurve(var_r28, temp_f29), var_r31);
|
||||
}
|
||||
}
|
||||
var_r28++;
|
||||
}
|
||||
var_r29++;
|
||||
}
|
||||
var_r31 = temp_r21;
|
||||
var_r31->unk04 = 0.0f;
|
||||
var_f26 = 0.0f;
|
||||
for (var_f31 = var_f26; var_f31 < var_r29 - 1; var_f31 += 1.0f, var_r31++) {
|
||||
PSVECSubtract(&var_r31[1].unk08, &var_r31[0].unk08, &sp3C);
|
||||
var_r31[1].unk04 = PSVECMag(&sp3C);
|
||||
var_f26 += var_r31[1].unk04;
|
||||
}
|
||||
var_r31 = temp_r21;
|
||||
var_f27 = 0.0f;
|
||||
var_f31 = var_f27;
|
||||
while (var_f31 < var_r29) {
|
||||
var_f27 += var_r31->unk04;
|
||||
var_r31->unk00 = arg5 * (var_f27 / var_f26);
|
||||
var_f31 += 1.0f;
|
||||
var_r31++;
|
||||
}
|
||||
var_f31 = 0.0f;
|
||||
while (var_f31 <= arg5) {
|
||||
switch (arg6) {
|
||||
case 0:
|
||||
var_f30 = var_f31;
|
||||
break;
|
||||
case 1:
|
||||
var_f30 = arg5 * sin(90.0f * (var_f31 / arg5) * M_PI / 180.0);
|
||||
break;
|
||||
case 2:
|
||||
var_f30 = arg5 * (1.0 - cos(90.0f * (var_f31 / arg5) * M_PI / 180.0));
|
||||
break;
|
||||
}
|
||||
var_r31 = temp_r21;
|
||||
for (var_r30 = 0; var_r30 < var_r29; var_r30++, var_r31++) {
|
||||
if (var_r31->unk00 <= var_f30 && var_r31[1].unk00 > var_f30) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (var_r30 != var_r29) {
|
||||
if (var_r30 == 0) {
|
||||
sp1C[0] = -1.0f;
|
||||
} else {
|
||||
sp1C[0] = var_r31[-1].unk00;
|
||||
}
|
||||
sp1C[1] = var_r31->unk00;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp1C[2] = 1.0f + var_r31->unk00;
|
||||
}
|
||||
sp1C[2] = var_r31[1].unk00;
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp1C[3] = 1.0f + sp1C[2];
|
||||
} else {
|
||||
sp1C[3] = var_r31[2].unk00;
|
||||
}
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31[0].unk08.x;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk08.x;
|
||||
}
|
||||
sp2C[1] = var_r31[0].unk08.x;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk08.x;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk08.x;
|
||||
}
|
||||
temp_r27->pos.x = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31[0].unk08.y;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk08.y;
|
||||
}
|
||||
sp2C[1] = var_r31[0].unk08.y;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk08.y;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk08.y;
|
||||
}
|
||||
temp_r27->pos.y = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31[0].unk08.z;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk08.z;
|
||||
}
|
||||
sp2C[1] = var_r31[0].unk08.z;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk08.z;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk08.z;
|
||||
}
|
||||
temp_r27->pos.z = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31[0].unk20.x;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk20.x;
|
||||
}
|
||||
sp2C[1] = var_r31[0].unk20.x;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk20.x;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk20.x;
|
||||
}
|
||||
temp_r27->target.x = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31->unk20.y;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk20.y;
|
||||
}
|
||||
sp2C[1] = var_r31->unk20.y;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk20.y;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk20.y;
|
||||
}
|
||||
temp_r27->target.y = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31->unk20.z;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk20.z;
|
||||
}
|
||||
sp2C[1] = var_r31->unk20.z;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk20.z;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk20.z;
|
||||
}
|
||||
temp_r27->target.z = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31->unk14.x;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk14.x;
|
||||
}
|
||||
sp2C[1] = var_r31->unk14.x;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk14.x;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk14.x;
|
||||
}
|
||||
temp_r27->up.x = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31->unk14.y;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk14.y;
|
||||
}
|
||||
sp2C[1] = var_r31->unk14.y;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk14.y;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk14.y;
|
||||
}
|
||||
temp_r27->up.y = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
if (var_r30 == 0) {
|
||||
sp2C[0] = var_r31->unk14.z;
|
||||
} else {
|
||||
sp2C[0] = var_r31[-1].unk14.z;
|
||||
}
|
||||
sp2C[1] = var_r31->unk14.z;
|
||||
if (var_r30 >= var_r29 - 1) {
|
||||
sp2C[2] = sp2C[1];
|
||||
} else {
|
||||
sp2C[2] = var_r31[1].unk14.z;
|
||||
}
|
||||
if (var_r30 >= var_r29 - 2) {
|
||||
sp2C[3] = sp2C[2];
|
||||
} else {
|
||||
sp2C[3] = var_r31[2].unk14.z;
|
||||
}
|
||||
temp_r27->up.z = InterpolateBMLine(sp2C, sp1C, var_f30);
|
||||
HuPrcVSleep();
|
||||
var_f31 += 1.0f;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
HuMemDirectFree(temp_r21);
|
||||
}
|
||||
|
||||
static void SetObjCamMotion(s16 arg0, HsfTrack *arg1, float arg2, HsfexStruct02 *arg3) {
|
||||
ModelData *temp_r31 = &Hu3DData[arg0];
|
||||
Vec sp18;
|
||||
Vec spC;
|
||||
|
||||
switch (arg1->channel) {
|
||||
case 8:
|
||||
arg3->unk08.x = temp_r31->scale.x * (arg2 + temp_r31->pos.x);
|
||||
break;
|
||||
case 9:
|
||||
arg3->unk08.y = temp_r31->scale.y * (arg2 + temp_r31->pos.y);
|
||||
break;
|
||||
case 10:
|
||||
arg3->unk08.z = temp_r31->scale.z * (arg2 + temp_r31->pos.z);
|
||||
break;
|
||||
case 11:
|
||||
arg3->unk20.x = temp_r31->scale.x * (arg2 + temp_r31->pos.x);
|
||||
break;
|
||||
case 12:
|
||||
arg3->unk20.y = temp_r31->scale.y * (arg2 + temp_r31->pos.y);
|
||||
break;
|
||||
case 13:
|
||||
arg3->unk20.z = temp_r31->scale.z * (arg2 + temp_r31->pos.z);
|
||||
break;
|
||||
case 14:
|
||||
PSVECSubtract(&arg3->unk08, &arg3->unk20, &spC);
|
||||
PSVECNormalize(&spC, &spC);
|
||||
sp18.x = spC.x * spC.y * (1.0 - cos(M_PI * arg2 / 180.0)) - spC.z * sin(M_PI * arg2 / 180.0);
|
||||
sp18.y = spC.y * spC.y + (1.0f - spC.y * spC.y) * cos(M_PI * arg2 / 180.0);
|
||||
sp18.z = spC.y * spC.z * (1.0 - cos(M_PI * arg2 / 180.0)) + spC.x * sin(M_PI * arg2 / 180.0);
|
||||
PSVECNormalize(&sp18, &arg3->unk14);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
float InterpolateBMLine(float *arg0, float *arg1, float arg2) {
|
||||
float sp8[2];
|
||||
float temp_f22;
|
||||
float var_f21;
|
||||
float temp_f20;
|
||||
float temp_f29;
|
||||
float temp_f31;
|
||||
float var_f28;
|
||||
float var_f27;
|
||||
float var_f26;
|
||||
float var_f25;
|
||||
float var_f24;
|
||||
float var_f23;
|
||||
float var_f30;
|
||||
s32 var_r30;
|
||||
s32 var_r29;
|
||||
s32 i;
|
||||
|
||||
if (arg0[0] == arg0[1] && arg0[0] == arg0[2] && arg0[0] == arg0[3]) {
|
||||
return arg0[0];
|
||||
}
|
||||
for (i = 1; i <= 2; i++) {
|
||||
sp8[i - 1] = 0.5f * ((arg0[i] - arg0[i - 1]) / (arg1[i] - arg1[i - 1]) + (arg0[i + 1] - arg0[i]) / (arg1[i + 1] - arg1[i]));
|
||||
}
|
||||
temp_f29 = 0.5f * (arg1[2] + arg1[1]);
|
||||
var_r30 = 0;
|
||||
if (sp8[1] - sp8[0] != 0.0f) {
|
||||
temp_f22 = (sp8[1] * arg1[2] - sp8[0] * arg1[1] - (arg0[2] - arg0[1])) / (sp8[1] - sp8[0]);
|
||||
var_r29 = 0;
|
||||
if (arg1[1] <= temp_f22 && temp_f22 <= arg1[2]) {
|
||||
var_r29 = 1;
|
||||
}
|
||||
var_r30 = (var_r29 != 0) ? 1 : 0;
|
||||
}
|
||||
if (var_r30 == 1) {
|
||||
temp_f31 = temp_f29 - arg1[1];
|
||||
temp_f20 = (arg0[2] - arg0[1]) / (arg1[2] - arg1[1]) - (sp8[1] - sp8[0]) / 2;
|
||||
var_f28 = temp_f20 * temp_f31 + ((sp8[1] - sp8[0]) / (2.0f * (arg1[2] - arg1[1]))) * temp_f31 * temp_f31 + arg0[1];
|
||||
var_f27 = temp_f20 + temp_f31 * ((sp8[1] - sp8[0]) / (arg1[2] - arg1[1]));
|
||||
} else {
|
||||
temp_f31 = temp_f29 - arg1[1];
|
||||
var_f28 = (arg0[2] + arg0[1]) * (temp_f31 / (arg1[2] - arg1[1]));
|
||||
var_f27 = 2.0f * (arg0[2] - arg0[1]) / (arg1[2] - arg1[1]) - (sp8[1] + sp8[0]) * (temp_f31 / (arg1[2] - arg1[1]));
|
||||
}
|
||||
if (arg2 < temp_f29) {
|
||||
var_f30 = arg1[1];
|
||||
var_f26 = arg0[1];
|
||||
var_f25 = sp8[0];
|
||||
var_f24 = temp_f29;
|
||||
var_f21 = var_f28;
|
||||
var_f23 = var_f27;
|
||||
} else {
|
||||
var_f30 = temp_f29;
|
||||
var_f26 = var_f28;
|
||||
var_f25 = var_f27;
|
||||
var_f24 = arg1[2];
|
||||
var_f21 = arg0[2];
|
||||
var_f23 = sp8[1];
|
||||
}
|
||||
return ((var_f23 - var_f25) / (2.0f * (var_f24 - var_f30))) * (arg2 - var_f30) * (arg2 - var_f30) + (arg2 - var_f30) * ((var_f21 - var_f26) / (var_f24 - var_f30) - (var_f23 - var_f25) / 2) + var_f26;
|
||||
}
|
||||
|
||||
void Hu3D2Dto3D(Vec *arg0, s16 arg1, Vec *arg2) {
|
||||
CameraData *temp_r31;
|
||||
float temp_f31;
|
||||
float temp_f30;
|
||||
float temp_f29;
|
||||
float temp_f28;
|
||||
float temp_f27;
|
||||
s16 i;
|
||||
Mtx spC;
|
||||
|
||||
for (i = 0; i < 16; i++) {
|
||||
if (arg1 & (1 << i)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
temp_r31 = &Hu3DCamera[i];
|
||||
temp_f30 = sin((temp_r31->fov / 2) * M_PI / 180.0) / cos((temp_r31->fov / 2) * M_PI / 180.0);
|
||||
temp_f31 = temp_f30 * arg0->z * 2.0f;
|
||||
temp_f29 = temp_f31 * 1.2f;
|
||||
temp_f28 = arg0->x / 576.0f;
|
||||
temp_f27 = arg0->y / 480.0f;
|
||||
arg2->x = (temp_f28 - 0.5) * temp_f29;
|
||||
arg2->y = -(temp_f27 - 0.5) * temp_f31;
|
||||
arg2->z = -arg0->z;
|
||||
C_MTXLookAt(spC, &temp_r31->pos, &temp_r31->up, &temp_r31->target);
|
||||
PSMTXInverse(spC, spC);
|
||||
PSMTXMultVec(spC, arg2, arg2);
|
||||
}
|
||||
|
||||
void Hu3D3Dto2D(Vec *arg0, s16 arg1, Vec *arg2) {
|
||||
Vec sp10;
|
||||
CameraData *temp_r31;
|
||||
float temp_f31;
|
||||
float temp_f30;
|
||||
s16 i;
|
||||
Mtx sp1C;
|
||||
|
||||
for (i = 0; i < 16; i++) {
|
||||
if (arg1 & (1 << i)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
temp_r31 = &Hu3DCamera[i];
|
||||
C_MTXLookAt(sp1C, &temp_r31->pos, &temp_r31->up, &temp_r31->target);
|
||||
PSMTXMultVec(sp1C, arg0, &sp10);
|
||||
temp_f31 = (sin((temp_r31->fov / 2) * M_PI / 180.0) / cos((temp_r31->fov / 2) * M_PI / 180.0)) * sp10.z * 1.2000000476837158;
|
||||
temp_f30 = (sin((temp_r31->fov / 2) * M_PI / 180.0) / cos((temp_r31->fov / 2) * M_PI / 180.0)) * sp10.z;
|
||||
arg2->x = 288.0f + sp10.x * (288.0f / -temp_f31);
|
||||
arg2->y = 240.0f + sp10.y * (240.0f / temp_f30);
|
||||
arg2->z = 0.0f;
|
||||
}
|
||||
|
||||
void Hu3DMtxTransGet(Mtx arg0, Vec *arg1) {
|
||||
arg1->x = arg0[0][3];
|
||||
arg1->y = arg0[1][3];
|
||||
arg1->z = arg0[2][3];
|
||||
}
|
||||
|
||||
static inline float GetAngleXY(float arg0, float arg1) {
|
||||
if (arg1 == 0.0f) {
|
||||
if (arg0 >= 0.0f) {
|
||||
return M_PI / 2;
|
||||
} else {
|
||||
return -(M_PI / 2);
|
||||
}
|
||||
} else {
|
||||
return atan2f(arg0, arg1);
|
||||
}
|
||||
}
|
||||
|
||||
void Hu3DMtxRotGet(Mtx arg0, Vec *arg1) {
|
||||
float sp48;
|
||||
float sp44;
|
||||
float sp3C;
|
||||
float sp34;
|
||||
float temp_f28;
|
||||
float temp_f27;
|
||||
float temp_f26;
|
||||
float var_f25;
|
||||
float temp_f24;
|
||||
|
||||
temp_f28 = arg0[0][0] * arg0[0][0] + arg0[1][0] * arg0[1][0] + arg0[2][0] * arg0[2][0];
|
||||
sp44 = sqrtf(temp_f28);
|
||||
if (!(sp44 < 0.00000001f)) {
|
||||
temp_f27 = arg0[0][1] * arg0[0][1] + arg0[1][1] * arg0[1][1] + arg0[2][1] * arg0[2][1];
|
||||
sp3C = sqrtf(temp_f27);
|
||||
if (!(sp3C < 0.00000001f)) {
|
||||
temp_f26 = arg0[0][2] * arg0[0][2] + arg0[1][2] * arg0[1][2] + arg0[2][2] * arg0[2][2];
|
||||
sp34 = sqrtf(temp_f26);
|
||||
if (!(sp34 < 0.00000001f)) {
|
||||
temp_f24 = -arg0[2][0] / sp44;
|
||||
if (temp_f24 >= 1.0f) {
|
||||
var_f25 = M_PI / 2;
|
||||
} else if (temp_f24 <= -1.0f) {
|
||||
var_f25 = -(M_PI / 2);
|
||||
} else {
|
||||
var_f25 = asinf(temp_f24);
|
||||
}
|
||||
arg1->y = var_f25;
|
||||
sp48 = cos(arg1->y);
|
||||
if (sp48 >= 0.00000001f) {
|
||||
arg1->x = GetAngleXY(arg0[2][1] / sp3C, arg0[2][2] / sp34);
|
||||
arg1->z = GetAngleXY(arg0[1][0], arg0[0][0]);
|
||||
} else {
|
||||
arg1->x = GetAngleXY(arg0[0][1], arg0[1][1]);
|
||||
arg1->z = 0.0f;
|
||||
}
|
||||
arg1->x = MTXRadToDeg(arg1->x);
|
||||
arg1->y = MTXRadToDeg(arg1->y);
|
||||
arg1->z = MTXRadToDeg(arg1->z);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
arg1->x = 0.0f;
|
||||
arg1->y = 0.0f;
|
||||
arg1->z = 0.0f;
|
||||
}
|
||||
|
||||
void Hu3DMtxScaleGet(Mtx arg0, Vec *arg1) {
|
||||
Vec sp38;
|
||||
Vec sp2C;
|
||||
Vec sp20;
|
||||
Vec sp14;
|
||||
Vec sp8;
|
||||
|
||||
sp2C.x = arg0[0][0];
|
||||
sp2C.y = arg0[1][0];
|
||||
sp2C.z = arg0[2][0];
|
||||
arg1->x = PSVECMag(&sp2C);
|
||||
PSVECNormalize(&sp2C, &sp2C);
|
||||
sp20.x = arg0[0][1];
|
||||
sp20.y = arg0[1][1];
|
||||
sp20.z = arg0[2][1];
|
||||
sp38.x = PSVECDotProduct(&sp2C, &sp20);
|
||||
PSVECScale(&sp2C, &sp8, sp38.x);
|
||||
PSVECSubtract(&sp20, &sp8, &sp20);
|
||||
arg1->y = PSVECMag(&sp20);
|
||||
PSVECNormalize(&sp20, &sp20);
|
||||
sp38.x /= arg1->y;
|
||||
sp14.x = arg0[0][2];
|
||||
sp14.y = arg0[1][2];
|
||||
sp14.z = arg0[2][2];
|
||||
sp38.z = PSVECDotProduct(&sp20, &sp14);
|
||||
PSVECScale(&sp20, &sp8, sp38.z);
|
||||
PSVECSubtract(&sp14, &sp8, &sp14);
|
||||
sp38.y = PSVECDotProduct(&sp2C, &sp14);
|
||||
PSVECScale(&sp2C, &sp8, sp38.y);
|
||||
PSVECSubtract(&sp14, &sp8, &sp14);
|
||||
arg1->z = PSVECMag(&sp14);
|
||||
PSVECNormalize(&sp14, &sp14);
|
||||
PSVECCrossProduct(&sp20, &sp14, &sp8);
|
||||
if (PSVECDotProduct(&sp2C, &sp8) < 0.0) {
|
||||
arg1->x *= -1.0;
|
||||
arg1->y *= -1.0;
|
||||
arg1->z *= -1.0;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,5 +1,18 @@
|
|||
#include "game/hsfman.h"
|
||||
#include "game/ClusterExec.h"
|
||||
#include "game/data.h"
|
||||
#include "game/EnvelopeExec.h"
|
||||
#include "game/hsfdraw.h"
|
||||
#include "game/hsfload.h"
|
||||
#include "game/hsfmotion.h"
|
||||
#include "game/init.h"
|
||||
#include "game/memory.h"
|
||||
#include "game/perf.h"
|
||||
#include "game/ShapeExec.h"
|
||||
#include "game/sprite.h"
|
||||
#include "dolphin/gx/GXVert.h"
|
||||
|
||||
#include "math.h"
|
||||
|
||||
ModelData Hu3DData[0x200];
|
||||
CameraData Hu3DCamera[0x10];
|
||||
|
|
@ -335,7 +348,7 @@ s16 Hu3DModelCreate(void *arg0) {
|
|||
var_r31->motion_attr = 0;
|
||||
var_r31->unk_02 = 0;
|
||||
MakeDisplayList(var_r30, (HsfData* ) var_r31->unk_48);
|
||||
var_r31->unk_68.x = 1.0f;
|
||||
var_r31->unk_68 = 1.0f;
|
||||
for (i = 0; i < 4; i++) {
|
||||
var_r31->unk_10[i] = -1;
|
||||
}
|
||||
|
|
@ -356,8 +369,8 @@ s16 Hu3DModelCreate(void *arg0) {
|
|||
if (var_r31->hsfData->shapeCnt != 0) {
|
||||
Hu3DMotionShapeSet(var_r30, var_r31->unk_08);
|
||||
}
|
||||
var_r31->unk_68.y = 0.0f;
|
||||
var_r31->unk_68.z = Hu3DMotionMaxTimeGet(var_r30);
|
||||
var_r31->unk_6C = 0.0f;
|
||||
var_r31->unk_70 = Hu3DMotionMaxTimeGet(var_r30);
|
||||
} else {
|
||||
var_r31->unk_20 = var_r31->unk_08 = -1;
|
||||
}
|
||||
|
|
@ -426,8 +439,8 @@ s16 Hu3DModelLink(s16 arg0) {
|
|||
var_r31->scale.x = var_r31->scale.y = var_r31->scale.z = 1.0f;
|
||||
var_r31->unk_08 = temp_r30->unk_08;
|
||||
if (var_r31->unk_08 != -1) {
|
||||
var_r31->unk_68.y = 0.0f;
|
||||
var_r31->unk_68.z = Hu3DMotionMaxTimeGet(var_r28);
|
||||
var_r31->unk_6C = 0.0f;
|
||||
var_r31->unk_70 = Hu3DMotionMaxTimeGet(var_r28);
|
||||
}
|
||||
var_r31->unk_0C = var_r31->unk_0A = var_r31->unk_0E = -1;
|
||||
for (i = 0; i < 4; i++) {
|
||||
|
|
@ -438,7 +451,7 @@ s16 Hu3DModelLink(s16 arg0) {
|
|||
}
|
||||
}
|
||||
var_r31->unk_64 = temp_r30->unk_64;
|
||||
var_r31->unk_68.x = temp_r30->unk_68.x;
|
||||
var_r31->unk_68 = temp_r30->unk_68;
|
||||
var_r31->unk_20 = temp_r30->unk_20;
|
||||
var_r31->camera = -1;
|
||||
var_r31->layer = 0;
|
||||
|
|
@ -458,7 +471,7 @@ s16 Hu3DModelLink(s16 arg0) {
|
|||
return var_r28;
|
||||
}
|
||||
|
||||
s16 Hu3DHookFuncCreate(HsfData* arg0) {
|
||||
s16 Hu3DHookFuncCreate(ModelHookFunc hook) {
|
||||
HsfData* sp8;
|
||||
ModelData* var_r31;
|
||||
s16 var_r29;
|
||||
|
|
@ -473,8 +486,8 @@ s16 Hu3DHookFuncCreate(HsfData* arg0) {
|
|||
if (var_r29 == 0x200) {
|
||||
return -1;
|
||||
}
|
||||
var_r31->hsfData = arg0;
|
||||
var_r31->unk_48 = (HsfData *)(var_r29 + 0x2710);
|
||||
var_r31->hook = hook;
|
||||
var_r31->unk_48 = (HsfData *)(var_r29 + 10000);
|
||||
var_r31->attr = 0x10;
|
||||
var_r31->motion_attr = 0;
|
||||
var_r31->pos.x = var_r31->pos.y = var_r31->pos.z = 0.0f;
|
||||
|
|
@ -486,7 +499,7 @@ s16 Hu3DHookFuncCreate(HsfData* arg0) {
|
|||
var_r31->unk_10[i] = -1;
|
||||
}
|
||||
var_r31->unk_64 = 0.0f;
|
||||
var_r31->unk_68.x = 1.0f;
|
||||
var_r31->unk_68 = 1.0f;
|
||||
var_r31->unk_20 = -1;
|
||||
var_r31->camera = -1;
|
||||
var_r31->layer = 0;
|
||||
|
|
@ -628,11 +641,11 @@ void Hu3DModelPosSet(s16 index, f32 x, f32 y, f32 z) {
|
|||
temp_r31->pos.z = z;
|
||||
}
|
||||
|
||||
void Hu3DModelPosSetV(s16 arg0, Vec arg1) {
|
||||
void Hu3DModelPosSetV(s16 arg0, Vec *arg1) {
|
||||
ModelData* temp_r31;
|
||||
|
||||
temp_r31 = &Hu3DData[arg0];
|
||||
temp_r31->pos = arg1;
|
||||
temp_r31->pos = *arg1;
|
||||
}
|
||||
|
||||
void Hu3DModelRotSet(s16 index, f32 x, f32 y, f32 z) {
|
||||
|
|
@ -644,11 +657,11 @@ void Hu3DModelRotSet(s16 index, f32 x, f32 y, f32 z) {
|
|||
temp_r31->rot.z = z;
|
||||
}
|
||||
|
||||
void Hu3DModelRotSetV(s16 arg0, Vec arg1) {
|
||||
void Hu3DModelRotSetV(s16 arg0, Vec *arg1) {
|
||||
ModelData* temp_r31;
|
||||
|
||||
temp_r31 = &Hu3DData[arg0];
|
||||
temp_r31->rot = arg1;
|
||||
temp_r31->rot = *arg1;
|
||||
}
|
||||
|
||||
void Hu3DModelScaleSet(s16 index, f32 x, f32 y, f32 z) {
|
||||
|
|
@ -660,11 +673,11 @@ void Hu3DModelScaleSet(s16 index, f32 x, f32 y, f32 z) {
|
|||
temp_r31->scale.z = z;
|
||||
}
|
||||
|
||||
void Hu3DModelScaleSetV(s16 arg0, Vec arg1) {
|
||||
void Hu3DModelScaleSetV(s16 arg0, Vec *arg1) {
|
||||
ModelData* temp_r31;
|
||||
|
||||
temp_r31 = &Hu3DData[arg0];
|
||||
temp_r31->scale = arg1;
|
||||
temp_r31->scale = *arg1;
|
||||
}
|
||||
|
||||
void Hu3DModelAttrSet(s16 arg0, u32 arg1) {
|
||||
|
|
@ -1289,7 +1302,7 @@ s16 Hu3DModelCameraCreate(s16 arg0, u16 arg1) {
|
|||
ModelData* temp_r31;
|
||||
s16 temp_r3;
|
||||
|
||||
temp_r3 = Hu3DHookFuncCreate((HsfData* )-1);
|
||||
temp_r3 = Hu3DHookFuncCreate((ModelHookFunc)-1);
|
||||
temp_r31 = &Hu3DData[(s16) temp_r3];
|
||||
temp_r31->attr &= ~0x10;
|
||||
temp_r31->attr |= 0x10000 | 0x2000;
|
||||
|
|
|
|||
1430
src/game/hsfmotion.c
Normal file
1430
src/game/hsfmotion.c
Normal file
File diff suppressed because it is too large
Load diff
74
src/game/jmp.c
Executable file
74
src/game/jmp.c
Executable file
|
|
@ -0,0 +1,74 @@
|
|||
#include "game/jmp.h"
|
||||
|
||||
int gcsetjmp(register jmp_buf *jump) {
|
||||
// clang-format off
|
||||
asm {
|
||||
mflr r5
|
||||
mfcr r6
|
||||
stw r5, jump->lr
|
||||
stw r6, jump->cr
|
||||
stw r1, jump->sp
|
||||
stw r2, jump->r2
|
||||
stmw r13, jump->regs[0]
|
||||
mffs f0
|
||||
stfd f14, jump->flt_regs[0]
|
||||
stfd f15, jump->flt_regs[1]
|
||||
stfd f16, jump->flt_regs[2]
|
||||
stfd f17, jump->flt_regs[3]
|
||||
stfd f18, jump->flt_regs[4]
|
||||
stfd f19, jump->flt_regs[5]
|
||||
stfd f20, jump->flt_regs[6]
|
||||
stfd f21, jump->flt_regs[7]
|
||||
stfd f22, jump->flt_regs[8]
|
||||
stfd f23, jump->flt_regs[9]
|
||||
stfd f24, jump->flt_regs[10]
|
||||
stfd f25, jump->flt_regs[11]
|
||||
stfd f26, jump->flt_regs[12]
|
||||
stfd f27, jump->flt_regs[13]
|
||||
stfd f28, jump->flt_regs[14]
|
||||
stfd f29, jump->flt_regs[15]
|
||||
stfd f30, jump->flt_regs[16]
|
||||
stfd f31, jump->flt_regs[17]
|
||||
stfd f0, jump->flt_regs[18]
|
||||
}
|
||||
// clang-format on
|
||||
return 0;
|
||||
}
|
||||
|
||||
// clang-format off
|
||||
asm int gclongjmp(register jmp_buf *jump, register int status) {
|
||||
nofralloc
|
||||
lwz r5, jump->lr
|
||||
lwz r6, jump->cr
|
||||
mtlr r5
|
||||
mtcrf 255, r6
|
||||
lwz r1, jump->sp
|
||||
lwz r2, jump->r2
|
||||
lmw r13, jump->regs[0]
|
||||
lfd f14, jump->flt_regs[0]
|
||||
lfd f15, jump->flt_regs[1]
|
||||
lfd f16, jump->flt_regs[2]
|
||||
lfd f17, jump->flt_regs[3]
|
||||
lfd f18, jump->flt_regs[4]
|
||||
lfd f19, jump->flt_regs[5]
|
||||
lfd f20, jump->flt_regs[6]
|
||||
lfd f21, jump->flt_regs[7]
|
||||
lfd f22, jump->flt_regs[8]
|
||||
lfd f23, jump->flt_regs[9]
|
||||
lfd f24, jump->flt_regs[10]
|
||||
lfd f25, jump->flt_regs[11]
|
||||
lfd f26, jump->flt_regs[12]
|
||||
lfd f27, jump->flt_regs[13]
|
||||
lfd f28, jump->flt_regs[14]
|
||||
lfd f29, jump->flt_regs[15]
|
||||
lfd f30, jump->flt_regs[16]
|
||||
lfd f0, jump->flt_regs[18]
|
||||
lfd f31, jump->flt_regs[17]
|
||||
cmpwi status, 0
|
||||
mr r3, status
|
||||
mtfsf 255, f0
|
||||
bnelr
|
||||
li r3, 1
|
||||
blr
|
||||
}
|
||||
// clang-format on
|
||||
|
|
@ -1,4 +1,6 @@
|
|||
#include "game/audio.h"
|
||||
#include "game/esprite.h"
|
||||
#include "game/hsfdraw.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/printfunc.h"
|
||||
#include "game/object.h"
|
||||
|
|
@ -140,7 +142,7 @@ void omOvlReturnEx(s16 level, s16 arg2)
|
|||
|
||||
void omOvlKill(s16 arg)
|
||||
{
|
||||
CharModelKillAll(-1);
|
||||
CharModelKill(-1);
|
||||
MGSeqKillAll();
|
||||
Hu3DAllKill();
|
||||
HuWinAllKill();
|
||||
|
|
|
|||
|
|
@ -4,9 +4,6 @@
|
|||
|
||||
#define PROCESS_MEMORY_RETADDR 0xA5A5A5A5
|
||||
|
||||
extern int gcsetjmp(jmp_buf *jump);
|
||||
extern void gclongjmp(jmp_buf *jump, int status);
|
||||
|
||||
#define EXEC_NORMAL 0
|
||||
#define EXEC_SLEEP 1
|
||||
#define EXEC_CHILDWATCH 2
|
||||
|
|
|
|||
252
src/game/thpmain.c
Executable file
252
src/game/thpmain.c
Executable file
|
|
@ -0,0 +1,252 @@
|
|||
#include "game/thpmain.h"
|
||||
#include "game/hsfdraw.h"
|
||||
#include "game/hsfman.h"
|
||||
#include "game/init.h"
|
||||
#include "game/process.h"
|
||||
#include "game/sprite.h"
|
||||
#include "game/THPSimple.h"
|
||||
|
||||
#include "string.h"
|
||||
|
||||
static void THPTestProc(void);
|
||||
static void THPViewFunc(ModelData *arg0, Mtx arg1);
|
||||
static void THPViewSprFunc(SpriteData *arg0);
|
||||
static void THPDecodeFunc(void *param);
|
||||
|
||||
static char THPFileName[64];
|
||||
|
||||
static UnkThpStruct04 audioTrack;
|
||||
static s32 decodeRate;
|
||||
static u8 *decodeStackP;
|
||||
static OSThread *decodeThread;
|
||||
static s16 THPLoopF;
|
||||
static s16 THPStat;
|
||||
static u32 THPFrame;
|
||||
static s16 THPStart;
|
||||
Process *THPProc;
|
||||
|
||||
s16 HuTHPSprCreateVol(char *path, s16 loop, s16 prio, float volume) {
|
||||
s16 temp_r31;
|
||||
|
||||
if (THPProc) {
|
||||
return -1;
|
||||
}
|
||||
THPStart = 0;
|
||||
THPProc = HuPrcCreate(THPTestProc, 0x64, 0x3000, 0);
|
||||
if (THPProc == 0) {
|
||||
return -1;
|
||||
}
|
||||
temp_r31 = HuSprFuncCreate(THPViewSprFunc, prio);
|
||||
if (temp_r31 == -1) {
|
||||
return -1;
|
||||
}
|
||||
THPSimpleInit(2);
|
||||
SimpleControl.unk19C = 0;
|
||||
SimpleControl.unk19E = temp_r31;
|
||||
SimpleControl.unkBC = volume;
|
||||
strcpy(THPFileName, path);
|
||||
THPLoopF = loop;
|
||||
THPStat = 0;
|
||||
THPFrame = 0;
|
||||
return temp_r31;
|
||||
}
|
||||
|
||||
s16 HuTHPSprCreate(char *path, s16 loop, s16 prio) {
|
||||
return HuTHPSprCreateVol(path, loop, prio, 110.0f);
|
||||
}
|
||||
|
||||
s16 HuTHP3DCreateVol(char *path, s16 loop, float volume) {
|
||||
s16 temp_r31;
|
||||
|
||||
if (THPProc) {
|
||||
return;
|
||||
}
|
||||
THPStart = 0;
|
||||
THPProc = HuPrcCreate(THPTestProc, 0x64, 0x3000, 0);
|
||||
if (THPProc == 0) {
|
||||
return -1;
|
||||
}
|
||||
THPSimpleInit(2);
|
||||
SimpleControl.unk19C = 1;
|
||||
temp_r31 = Hu3DHookFuncCreate(&THPViewFunc);
|
||||
SimpleControl.unk19E = temp_r31;
|
||||
SimpleControl.unkBC = volume;
|
||||
strcpy(THPFileName, path);
|
||||
THPLoopF = loop;
|
||||
THPStat = 0;
|
||||
THPFrame = 0;
|
||||
Hu3DModelAttrSet(SimpleControl.unk19E, 1);
|
||||
return temp_r31;
|
||||
}
|
||||
|
||||
s16 HuTHP3DCreate(char *path, s16 loop) {
|
||||
return HuTHP3DCreateVol(path, loop, 110.0f);
|
||||
}
|
||||
|
||||
void HuTHPStop(void) {
|
||||
THPStat = 1;
|
||||
}
|
||||
|
||||
void HuTHPClose(void) {
|
||||
THPStat = 2;
|
||||
}
|
||||
|
||||
void HuTHPRestart(void) {
|
||||
THPStat = 3;
|
||||
}
|
||||
|
||||
BOOL HuTHPEndCheck(void) {
|
||||
s32 temp_r31;
|
||||
|
||||
temp_r31 = THPSimpleGetTotalFrame() - 1;
|
||||
if (temp_r31 <= 0) {
|
||||
return FALSE;
|
||||
}
|
||||
return (temp_r31 <= THPFrame);
|
||||
}
|
||||
|
||||
s32 HuTHPFrameGet(void) {
|
||||
return THPFrame;
|
||||
}
|
||||
|
||||
s32 HuTHPTotalFrameGet(void) {
|
||||
return THPSimpleGetTotalFrame();
|
||||
}
|
||||
|
||||
void HuTHPSetVolume(s32 left, s32 right) {
|
||||
THPSimpleSetVolume(left, right);
|
||||
}
|
||||
|
||||
static void THPTestProc(void) {
|
||||
s32 temp_r29;
|
||||
u32 var_r28;
|
||||
void *temp_r30;
|
||||
|
||||
while (THPSimpleOpen(THPFileName) == 0) {
|
||||
OSReport("THPSimpleOpen fail");
|
||||
HuPrcVSleep();
|
||||
}
|
||||
THPSimpleGetVideoInfo(&audioTrack);
|
||||
temp_r29 = THPSimpleCalcNeedMemory();
|
||||
OSReport("Size %x\n", temp_r29);
|
||||
temp_r30 = HuMemDirectMalloc(HEAP_DATA, temp_r29);
|
||||
memset(temp_r30, 0, temp_r29);
|
||||
DCFlushRange(temp_r30, temp_r29);
|
||||
if (temp_r30 == 0) {
|
||||
OSReport("Can't allocate the memory\n");
|
||||
}
|
||||
THPSimpleSetBuffer(temp_r30);
|
||||
while (THPSimplePreLoad(THPLoopF) == 0) {
|
||||
OSReport("THPSimplePreLoad fail");
|
||||
HuPrcVSleep();
|
||||
}
|
||||
HuPrcVSleep();
|
||||
decodeStackP = HuMemDirectMalloc(HEAP_SYSTEM, 0x2000);
|
||||
decodeThread = OSSetIdleFunction(THPDecodeFunc, NULL, decodeStackP + 0x2000, 0x2000);
|
||||
decodeRate = 0;
|
||||
THPStart = 1;
|
||||
if (SimpleControl.unk19C == 1) {
|
||||
Hu3DModelAttrReset(SimpleControl.unk19E, 1);
|
||||
} else {
|
||||
HuSprAttrReset(SimpleControl.unk19E, 0, 4);
|
||||
}
|
||||
while (1) {
|
||||
if (THPStat == 2) {
|
||||
break;
|
||||
}
|
||||
switch (THPStat) {
|
||||
case 0:
|
||||
var_r28 = 1;
|
||||
THPStat = 4;
|
||||
break;
|
||||
case 1:
|
||||
THPSimpleAudioStop();
|
||||
THPSimpleLoadStop();
|
||||
break;
|
||||
case 3:
|
||||
THPSimpleAudioStop();
|
||||
THPSimpleLoadStop();
|
||||
while (THPSimplePreLoad(THPLoopF) == 0) {
|
||||
OSReport("THPSimplePreLoad fail");
|
||||
HuPrcVSleep();
|
||||
}
|
||||
THPStat = 0;
|
||||
var_r28 = 1;
|
||||
break;
|
||||
}
|
||||
if (var_r28 != 0) {
|
||||
THPSimpleAudioStart();
|
||||
var_r28 = 0;
|
||||
}
|
||||
HuPrcVSleep();
|
||||
}
|
||||
if (SimpleControl.unk19C == 1) {
|
||||
Hu3DModelKill(SimpleControl.unk19E);
|
||||
} else {
|
||||
HuSprKill(SimpleControl.unk19E);
|
||||
}
|
||||
OSCancelThread(decodeThread);
|
||||
HuMemDirectFree(decodeStackP);
|
||||
THPSimpleAudioStop();
|
||||
THPSimpleLoadStop();
|
||||
THPSimpleClose();
|
||||
HuMemDirectFree(temp_r30);
|
||||
THPSimpleQuit();
|
||||
THPProc = NULL;
|
||||
HuPrcKill(HuPrcCurrentGet());
|
||||
while (1) {
|
||||
HuPrcVSleep();
|
||||
}
|
||||
}
|
||||
|
||||
static void THPViewFunc(ModelData *arg0, Mtx arg1) {
|
||||
GXColor spC = { 0xFF, 0xFF, 0xFF, 0xFF };
|
||||
|
||||
if (THPStart != 0) {
|
||||
GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
THPFrame = THPSimpleDrawCurrentFrame(RenderMode, &spC, arg1, -audioTrack.unk00 / 2, audioTrack.unk04 / 2, audioTrack.unk00, -audioTrack.unk04);
|
||||
THPSimpleAudioStart();
|
||||
}
|
||||
}
|
||||
|
||||
static void THPViewSprFunc(SpriteData *arg0) {
|
||||
Vec spC = { 0.0f, 0.0f, 1.0f };
|
||||
GXColor sp8;
|
||||
s32 temp_r30;
|
||||
s32 temp_r29;
|
||||
Mtx sp48;
|
||||
Mtx sp18;
|
||||
|
||||
if (THPStart != 0) {
|
||||
sp8.r = arg0->r;
|
||||
sp8.g = arg0->g;
|
||||
sp8.b = arg0->b;
|
||||
sp8.a = arg0->a;
|
||||
if (arg0->z_rot != 0.0f) {
|
||||
PSMTXRotAxisRad(sp18, &spC, MTXDegToRad(arg0->z_rot));
|
||||
PSMTXScale(sp48, arg0->scale_x, arg0->scale_y, 1.0f);
|
||||
PSMTXConcat(sp18, sp48, sp48);
|
||||
} else {
|
||||
PSMTXScale(sp48, arg0->scale_x, arg0->scale_y, 1.0f);
|
||||
}
|
||||
mtxTransCat(sp48, arg0->x, arg0->y, 0.0f);
|
||||
PSMTXConcat(*arg0->group_mtx, sp48, sp48);
|
||||
temp_r30 = -((s32) audioTrack.unk00 / 2);
|
||||
temp_r29 = -((s32) audioTrack.unk04 / 2);
|
||||
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
THPFrame = THPSimpleDrawCurrentFrame(RenderMode, &sp8, sp48, temp_r30, temp_r29, audioTrack.unk00, audioTrack.unk04);
|
||||
}
|
||||
}
|
||||
|
||||
static void THPDecodeFunc(void *param) {
|
||||
while (1) {
|
||||
if (THPStat == 2) {
|
||||
break;
|
||||
}
|
||||
if (THPSimpleDecode() == 1) {
|
||||
OSReport("Fail to decode video data");
|
||||
}
|
||||
VIWaitForRetrace();
|
||||
}
|
||||
}
|
||||
|
|
@ -201,14 +201,12 @@ void HuWindowInit(void) {
|
|||
void HuWinInit(s32 mess_data_no) {
|
||||
s16 i;
|
||||
void *anim_data;
|
||||
s8 language;
|
||||
|
||||
if (!winProc) {
|
||||
HuAR_ARAMtoMRAM(winAMemP);
|
||||
winProc = HuPrcCreate(HuWinProc, 0x64, 0x1000, 0);
|
||||
HuPrcSetStat(winProc, 0xC);
|
||||
language = GWGameStat.language;
|
||||
LanguageNo = language;
|
||||
LanguageNo = GWLanguageGet();
|
||||
messDataNo = mess_data_no;
|
||||
fontWidthP = (LanguageNo == 0) ? charWJTbl : charWETbl;
|
||||
HuWinMesRead(mess_data_no);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue