mirror of
https://gitlab.com/ryandwyer/perfect-dark
synced 2026-07-10 05:46:45 -04:00
Ryan Dwyer
749 lines
15 KiB
C
749 lines
15 KiB
C
#include <ultra64.h>
|
|
#include "constants.h"
|
|
#include "game/prop.h"
|
|
#include "game/game_1531a0.h"
|
|
#include "game/bg.h"
|
|
#include "bss.h"
|
|
#include "lib/dma.h"
|
|
#include "lib/memp.h"
|
|
#include "lib/mtx.h"
|
|
#include "lib/anim.h"
|
|
#include "lib/lib_2f490.h"
|
|
#include "lib/libc/ll.h"
|
|
#include "data.h"
|
|
#include "types.h"
|
|
|
|
u8 *var8009a870;
|
|
u8 **var8009a874;
|
|
s16 *var8009a878;
|
|
s16 *var8009a87c;
|
|
u8 *var8009a880;
|
|
u8 *var8009a884;
|
|
u8 **var8009a888;
|
|
s16 *var8009a88c;
|
|
s32 *var8009a890;
|
|
s16 var8009a894;
|
|
struct animsummary *var8009a898;
|
|
|
|
u32 var8005f000 = 0;
|
|
s32 var8005f004 = 0;
|
|
s16 g_NumAnimations = 0;
|
|
struct animsummary *g_Anims = NULL;
|
|
u8 *var8005f010 = NULL;
|
|
s16 *var8005f014 = NULL;
|
|
s32 var8005f018 = 176;
|
|
s32 var8005f01c = 608;
|
|
bool g_AnimHostEnabled = false;
|
|
u8 *g_AnimHostSegment = NULL;
|
|
|
|
extern u8 _animationsTableRomStart;
|
|
extern u8 _animationsTableRomEnd;
|
|
|
|
void animsInit(void)
|
|
{
|
|
s32 i;
|
|
u32 *ptr;
|
|
u32 tablelen = ALIGN64(&_animationsTableRomEnd - &_animationsTableRomStart);
|
|
|
|
ptr = mempAlloc(tablelen, MEMPOOL_PERMANENT);
|
|
dmaExec(ptr, (s32)&_animationsTableRomStart, tablelen);
|
|
|
|
g_NumAnimations = var8009a894 = ptr[0];
|
|
g_Anims = var8009a898 = (struct animsummary *)&ptr[1];
|
|
|
|
var8005f01c = 1;
|
|
var8005f018 = 1;
|
|
|
|
for (i = 0; i < g_NumAnimations; i++) {
|
|
if (g_Anims[i].headerlen > var8005f01c) {
|
|
var8005f01c = g_Anims[i].headerlen;
|
|
}
|
|
|
|
if (g_Anims[i].bytesperframe > var8005f018) {
|
|
var8005f018 = g_Anims[i].bytesperframe;
|
|
}
|
|
}
|
|
|
|
var8005f01c = ALIGN16(var8005f01c + 34);
|
|
var8005f018 = ALIGN16(var8005f018 + 34);
|
|
|
|
var8005f010 = mempAlloc(ALIGN64(g_NumAnimations), MEMPOOL_PERMANENT);
|
|
var8005f014 = mempAlloc(ALIGN64(g_NumAnimations * 2), MEMPOOL_PERMANENT);
|
|
var8009a870 = mempAlloc(ALIGN64(var8005f018 * 0x20), MEMPOOL_PERMANENT);
|
|
var8009a874 = mempAlloc(0x80, MEMPOOL_PERMANENT);
|
|
var8009a878 = mempAlloc(0x40, MEMPOOL_PERMANENT);
|
|
var8009a87c = mempAlloc(0x40, MEMPOOL_PERMANENT);
|
|
var8009a880 = mempAlloc(0x40, MEMPOOL_PERMANENT);
|
|
var8009a884 = mempAlloc(ALIGN64(var8005f01c * 40), MEMPOOL_PERMANENT);
|
|
var8009a888 = mempAlloc(0xc0, MEMPOOL_PERMANENT);
|
|
var8009a88c = mempAlloc(0x80, MEMPOOL_PERMANENT);
|
|
var8009a890 = mempAlloc(0xc0, MEMPOOL_PERMANENT);
|
|
|
|
animsInitTables();
|
|
|
|
g_AnimHostSegment = NULL;
|
|
g_AnimHostEnabled = false;
|
|
}
|
|
|
|
void animsInitTables(void)
|
|
{
|
|
s32 i;
|
|
|
|
for (i = 0; i < g_NumAnimations; i++) {
|
|
var8005f010[i] = 0xff;
|
|
var8005f014[i] = 0;
|
|
}
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
var8009a878[i] = 0;
|
|
var8009a87c[i] = 0;
|
|
var8009a880[i] = 0;
|
|
}
|
|
|
|
for (i = 0; i < 40; i++) {
|
|
var8009a88c[i] = 0;
|
|
var8009a890[i] = -2;
|
|
}
|
|
}
|
|
|
|
void animsReset(void)
|
|
{
|
|
g_NumAnimations = var8009a894;
|
|
g_Anims = var8009a898;
|
|
g_AnimHostEnabled = false;
|
|
}
|
|
|
|
s32 animGetNumFrames(s16 animnum)
|
|
{
|
|
return g_Anims[animnum].numframes;
|
|
}
|
|
|
|
bool animHasFrames(s16 animnum)
|
|
{
|
|
return animnum < g_NumAnimations && g_Anims[animnum].numframes > 0;
|
|
}
|
|
|
|
s32 animGetNumAnimations(void)
|
|
{
|
|
return g_NumAnimations;
|
|
}
|
|
|
|
extern u8 _animationsSegmentRomStart;
|
|
|
|
u8 *animDma(u8 *dst, u32 segoffset, u32 len)
|
|
{
|
|
if (g_AnimHostEnabled) {
|
|
bcopy(&g_AnimHostSegment[segoffset], dst, len);
|
|
return dst;
|
|
}
|
|
|
|
return dmaExecWithAutoAlign(dst, (u32)&_animationsSegmentRomStart + segoffset, len);
|
|
}
|
|
|
|
s32 anim0002384c(s16 animnum, s32 frame)
|
|
{
|
|
u8 *ptr = (u8 *)(var8009a888[var8005f010[animnum]] + g_Anims[animnum].headerlen - 2);
|
|
s32 result = frame;
|
|
|
|
while (true) {
|
|
s16 value1 = ptr[0] << 8 | ptr[1];
|
|
s16 value2;
|
|
|
|
if (value1 < 0) {
|
|
break;
|
|
}
|
|
|
|
value2 = ptr[-2] << 8 | ptr[-1];
|
|
ptr -= 4;
|
|
|
|
if (value1 <= frame) {
|
|
if (value2 < frame) {
|
|
result = result - value2 + value1 - 1;
|
|
} else {
|
|
result = -1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool anim00023908(s16 animnum, s32 frame, s32 *frameptr)
|
|
{
|
|
u8 *ptr = (u8 *)(var8009a888[var8005f010[animnum]] + g_Anims[animnum].headerlen - 2);
|
|
s32 result = frame;
|
|
bool ret = true;
|
|
|
|
while (true) {
|
|
s16 value1 = ptr[0] << 8 | ptr[1];
|
|
|
|
if (value1 >= 0) {
|
|
s16 value2 = ptr[-2] << 8 | ptr[-1];
|
|
ptr -= 4;
|
|
|
|
if (value1 <= frame) {
|
|
if (value2 < frame) {
|
|
result = result - value2 + value1 - 1;
|
|
continue;
|
|
}
|
|
|
|
result = result - frame + value1;
|
|
ret = false;
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
*frameptr = result;
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool anim000239e0(s16 animnum, s32 frame)
|
|
{
|
|
u8 *ptr = (u8 *)(var8009a888[var8005f010[animnum]] + g_Anims[animnum].headerlen - 2);
|
|
|
|
if (g_Anims[animnum].flags & ANIMFLAG_04) {
|
|
while (true) {
|
|
s16 value1 = ptr[0] << 8 | ptr[1];
|
|
|
|
if (value1 < 0) {
|
|
break;
|
|
}
|
|
|
|
ptr -= 4;
|
|
}
|
|
|
|
ptr -= 2;
|
|
}
|
|
|
|
while (true) {
|
|
s16 value2 = ptr[0] << 8 | ptr[1];
|
|
|
|
if (value2 < 0) {
|
|
break;
|
|
}
|
|
|
|
if (value2 == frame) {
|
|
return true;
|
|
}
|
|
|
|
ptr -= 2;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
u8 anim00023ab0(s16 animnum, s32 framenum)
|
|
{
|
|
s32 index = -1;
|
|
s32 i;
|
|
s32 offset;
|
|
s32 stack;
|
|
s32 sp2c = framenum;
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
if (var8009a878[i] == animnum && var8009a87c[i] == sp2c) {
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (index >= 0) {
|
|
var8009a880[index] = 1;
|
|
} else {
|
|
index = var8005f000;
|
|
|
|
while (var8009a880[index]) {
|
|
index = (index + 1) % 32;
|
|
}
|
|
|
|
if (g_Anims[animnum].flags & ANIMFLAG_04) {
|
|
anim00023908(animnum, framenum, &sp2c);
|
|
}
|
|
|
|
if (g_Anims[animnum].bytesperframe) {
|
|
offset = g_Anims[animnum].bytesperframe * sp2c + (g_Anims[animnum].data + g_Anims[animnum].headerlen);
|
|
var8009a874[index] = animDma(&var8009a870[index * var8005f018], offset, g_Anims[animnum].bytesperframe);
|
|
} else {
|
|
var8009a874[index] = &var8009a870[index * var8005f018];
|
|
}
|
|
|
|
var8009a878[index] = animnum;
|
|
var8009a87c[index] = framenum;
|
|
var8009a880[index] = 1;
|
|
var8005f000 = (index + 1) % 32;
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
void anim00023d0c(void)
|
|
{
|
|
s32 i;
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
var8009a880[i] = 0;
|
|
}
|
|
}
|
|
|
|
void anim00023d38(s16 animnum)
|
|
{
|
|
s32 i;
|
|
|
|
if (var8005f010[animnum] != 0xff) {
|
|
var8009a890[var8005f010[animnum]] = g_Vars.thisframestart240;
|
|
var8005f004 = (var8005f010[animnum] + 1) % 40;
|
|
} else {
|
|
s32 tmp;
|
|
s32 bestindex = var8005f004;
|
|
s32 stack;
|
|
|
|
for (i = 0; i < 40; i++) {
|
|
if (var8009a890[i] < var8009a890[bestindex]) {
|
|
bestindex = i;
|
|
}
|
|
}
|
|
|
|
if (var8009a890[bestindex]);
|
|
if (&g_Vars && &g_Vars);
|
|
|
|
if (var8009a88c[bestindex]) {
|
|
var8005f010[var8009a88c[bestindex]] = 0xff;
|
|
}
|
|
|
|
tmp = g_Anims[animnum].headerlen;
|
|
|
|
var8009a888[bestindex] = animDma(&var8009a884[bestindex * var8005f01c], g_Anims[animnum].data, tmp);
|
|
var8005f010[animnum] = bestindex;
|
|
var8009a88c[bestindex] = animnum;
|
|
var8009a890[bestindex] = g_Vars.thisframestart240;
|
|
var8005f004 = (bestindex + 1) % 40;
|
|
}
|
|
}
|
|
|
|
#if MATCHING
|
|
GLOBAL_ASM(
|
|
glabel anim00023f50
|
|
/* 23f50: 30cf0007 */ andi $t7,$a2,0x7
|
|
/* 23f54: 24180008 */ addiu $t8,$zero,0x8
|
|
/* 23f58: 030f4023 */ subu $t0,$t8,$t7
|
|
/* 23f5c: 30a900ff */ andi $t1,$a1,0xff
|
|
/* 23f60: 311900ff */ andi $t9,$t0,0xff
|
|
/* 23f64: 000610c2 */ srl $v0,$a2,0x3
|
|
/* 23f68: 0139082a */ slt $at,$t1,$t9
|
|
/* 23f6c: afa50004 */ sw $a1,0x4($sp)
|
|
/* 23f70: 00001825 */ or $v1,$zero,$zero
|
|
/* 23f74: 00822021 */ addu $a0,$a0,$v0
|
|
/* 23f78: 1420000e */ bnez $at,.L00023fb4
|
|
/* 23f7c: 310700ff */ andi $a3,$t0,0xff
|
|
.L00023f80:
|
|
/* 23f80: 908b0000 */ lbu $t3,0x0($a0)
|
|
/* 23f84: 240c0001 */ addiu $t4,$zero,0x1
|
|
/* 23f88: 01272823 */ subu $a1,$t1,$a3
|
|
/* 23f8c: 00ec6804 */ sllv $t5,$t4,$a3
|
|
/* 23f90: 30a900ff */ andi $t1,$a1,0xff
|
|
/* 23f94: 25aeffff */ addiu $t6,$t5,-1
|
|
/* 23f98: 016e7824 */ and $t7,$t3,$t6
|
|
/* 23f9c: 012fc004 */ sllv $t8,$t7,$t1
|
|
/* 23fa0: 29210008 */ slti $at,$t1,0x8
|
|
/* 23fa4: 00781825 */ or $v1,$v1,$t8
|
|
/* 23fa8: 24840001 */ addiu $a0,$a0,0x1
|
|
/* 23fac: 1020fff4 */ beqz $at,.L00023f80
|
|
/* 23fb0: 24070008 */ addiu $a3,$zero,0x8
|
|
.L00023fb4:
|
|
/* 23fb4: 19200008 */ blez $t1,.L00023fd8
|
|
/* 23fb8: 00e95023 */ subu $t2,$a3,$t1
|
|
/* 23fbc: 90990000 */ lbu $t9,0x0($a0)
|
|
/* 23fc0: 240d0001 */ addiu $t5,$zero,0x1
|
|
/* 23fc4: 012d5804 */ sllv $t3,$t5,$t1
|
|
/* 23fc8: 256effff */ addiu $t6,$t3,-1
|
|
/* 23fcc: 01596007 */ srav $t4,$t9,$t2
|
|
/* 23fd0: 018e7824 */ and $t7,$t4,$t6
|
|
/* 23fd4: 006f1825 */ or $v1,$v1,$t7
|
|
.L00023fd8:
|
|
/* 23fd8: 03e00008 */ jr $ra
|
|
/* 23fdc: 00601025 */ or $v0,$v1,$zero
|
|
);
|
|
#else
|
|
// Mismatch: regalloc
|
|
s32 anim00023f50(u8 *arg0, u8 arg1, u32 arg2)
|
|
{
|
|
u32 result = 0;
|
|
u8 numbits;
|
|
u32 tmp;
|
|
|
|
arg0 += arg2 / 8;
|
|
numbits = 8 - (arg2 % 8);
|
|
|
|
while (arg1 >= numbits) {
|
|
arg1 -= numbits;
|
|
result |= (*arg0 & ((1 << numbits) - 1)) << arg1;
|
|
arg0++;
|
|
numbits = 8;
|
|
}
|
|
|
|
if (arg1 > 0) {
|
|
result |= (*arg0 >> (numbits - arg1)) & ((1 << arg1) - 1);
|
|
}
|
|
|
|
if (arg2 / 8);
|
|
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
s32 anim00023fe0(u8 *arg0, u8 arg1, s32 arg2)
|
|
{
|
|
u16 result = anim00023f50(arg0, arg1, arg2);
|
|
|
|
if (arg1 < 16 && (result & (1 << (arg1 - 1)))) {
|
|
result |= ((1 << (16 - arg1)) - 1) << arg1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void anim00024050(s32 arg0, bool flip, struct skeleton *skel, s16 animnum, u8 arg4, struct coord *arg5, struct coord *arg6, struct coord *arg7)
|
|
{
|
|
s32 i;
|
|
u16 sp5c[3];
|
|
u8 sp5b;
|
|
u8 *sp54 = var8009a874[arg4];
|
|
u8 bitsperentry;
|
|
u8 *ptr;
|
|
u8 *end;
|
|
s32 sum;
|
|
u32 stack;
|
|
|
|
if (flip) {
|
|
arg0 = skel->things[arg0][1];
|
|
}
|
|
|
|
bitsperentry = g_Anims[animnum].initialposbitsperentry;
|
|
ptr = var8009a888[var8005f010[animnum]];
|
|
sum = 0;
|
|
end = ptr + g_Anims[animnum].headerlen;
|
|
|
|
for (i = 0; i < arg0 && ptr < end; i++) {
|
|
u8 flags = *ptr;
|
|
ptr++;
|
|
|
|
if (flags & 0x08) {
|
|
sum += ptr[2] + ptr[5] + ptr[8] + ptr[11];
|
|
ptr += 12;
|
|
} else if (flags & 0x02) {
|
|
sum += ptr[2] + ptr[5] + ptr[8];
|
|
ptr += 9;
|
|
} else if (flags & 0x20) {
|
|
sum += ptr[0] + ptr[5] + ptr[10];
|
|
ptr += 15;
|
|
}
|
|
|
|
if (flags & 0x01) {
|
|
sum += ptr[2] + ptr[5] + ptr[8];
|
|
ptr += 9;
|
|
} else if (flags & 0x10) {
|
|
sum += 96;
|
|
}
|
|
|
|
if (flags & 0x40) {
|
|
sum += ptr[0];
|
|
ptr += 5;
|
|
}
|
|
|
|
if (flags & 0x80) {
|
|
sum += 0x60;
|
|
}
|
|
}
|
|
|
|
if (ptr < end) {
|
|
u8 flags = *ptr;
|
|
ptr++;
|
|
|
|
if (flags & 0x02) {
|
|
sp5b = ptr[2];
|
|
arg6->x = (s16) (anim00023fe0(sp54, sp5b, sum) + (ptr[0] << 8) + ptr[1]);
|
|
sum += sp5b;
|
|
|
|
sp5b = ptr[5];
|
|
arg6->y = (s16) (anim00023fe0(sp54, sp5b, sum) + (ptr[3] << 8) + ptr[4]);
|
|
sum += sp5b;
|
|
|
|
sp5b = ptr[8];
|
|
arg6->z = (s16) (anim00023fe0(sp54, sp5b, sum) + (ptr[6] << 8) + ptr[7]);
|
|
sum += sp5b;
|
|
|
|
ptr += 9;
|
|
} else if (flags & 0x20) {
|
|
sp5b = ptr[0];
|
|
arg6->x = (anim00023f50(sp54, sp5b, sum) + ((ptr[1] << 24) + (ptr[2] << 16) + (ptr[3] << 8) + ptr[4])) * 0.001f;
|
|
sum += sp5b;
|
|
|
|
sp5b = ptr[5];
|
|
arg6->y = (anim00023f50(sp54, sp5b, sum) + ((ptr[6] << 24) + (ptr[7] << 16) + (ptr[8] << 8) + ptr[9])) * 0.001f;
|
|
sum += sp5b;
|
|
|
|
sp5b = ptr[10];
|
|
arg6->z = (anim00023f50(sp54, sp5b, sum) + ((ptr[11] << 24) + (ptr[12] << 16) + (ptr[13] << 8) + ptr[14])) * 0.001f;
|
|
sum += sp5b;
|
|
|
|
ptr += 15;
|
|
} else {
|
|
if (flags & 0x08) {
|
|
sum += ptr[2] + ptr[5] + ptr[8] + ptr[11];
|
|
ptr += 12;
|
|
}
|
|
|
|
arg6->x = arg6->y = arg6->z = 0.0f;
|
|
}
|
|
|
|
if (flags & 0x01) {
|
|
sp5b = ptr[2];
|
|
sp5c[0] = anim00023f50(sp54, sp5b, sum);
|
|
sp5c[0] += (ptr[0] << 8) + ptr[1];
|
|
sp5c[0] <<= 16 - bitsperentry;
|
|
sum += sp5b;
|
|
|
|
sp5b = ptr[5];
|
|
sp5c[1] = anim00023f50(sp54, sp5b, sum);
|
|
sp5c[1] += (ptr[3] << 8) + ptr[4];
|
|
sp5c[1] <<= 16 - bitsperentry;
|
|
sum += sp5b;
|
|
|
|
sp5b = ptr[8];
|
|
sp5c[2] = anim00023f50(sp54, sp5b, sum);
|
|
sp5c[2] += (ptr[6] << 8) + ptr[7];
|
|
sp5c[2] <<= 16 - bitsperentry;
|
|
sum += sp5b;
|
|
|
|
arg5->x = sp5c[0] * M_BADTAU / 65536.0f;
|
|
|
|
if (flip) {
|
|
if (sp5c[1] != 0) {
|
|
arg5->y = (0x10000 - sp5c[1]) * M_BADTAU / 65536.0f;
|
|
} else {
|
|
arg5->y = 0.0f;
|
|
}
|
|
|
|
if (sp5c[2] != 0) {
|
|
arg5->z = (0x10000 - sp5c[2]) * M_BADTAU / 65536.0f;
|
|
} else {
|
|
arg5->z = 0.0f;
|
|
}
|
|
} else {
|
|
arg5->y = sp5c[1] * M_BADTAU / 65536.0f;
|
|
arg5->z = sp5c[2] * M_BADTAU / 65536.0f;
|
|
}
|
|
} else if (flags & 0x10) {
|
|
s32 sp38;
|
|
|
|
sp38 = anim00023f50(sp54, 32, sum);
|
|
arg5->x = *(f32 *)&sp38;
|
|
sum += 32;
|
|
|
|
sp38 = anim00023f50(sp54, 32, sum);
|
|
arg5->y = *(f32 *)&sp38;
|
|
sum += 32;
|
|
|
|
sp38 = anim00023f50(sp54, 32, sum);
|
|
arg5->z = *(f32 *)&sp38;
|
|
sum += 32;
|
|
|
|
if (flip) {
|
|
if (arg5->y != 0.0f) {
|
|
arg5->y = M_BADTAU - arg5->y;
|
|
}
|
|
|
|
if (arg5->z != 0.0f) {
|
|
arg5->z = M_BADTAU - arg5->z;
|
|
}
|
|
}
|
|
} else {
|
|
arg5->x = arg5->y = arg5->z = 0.0f;
|
|
}
|
|
|
|
if (flags & 0x80) {
|
|
s32 sp34;
|
|
|
|
sp34 = anim00023f50(sp54, 32, sum);
|
|
arg7->x = *(f32 *)&sp34;
|
|
sum += 32;
|
|
|
|
sp34 = anim00023f50(sp54, 32, sum);
|
|
arg7->y = *(f32 *)&sp34;
|
|
sum += 32;
|
|
|
|
sp34 = anim00023f50(sp54, 32, sum);
|
|
arg7->z = *(f32 *)&sp34;
|
|
} else {
|
|
arg7->x = arg7->y = arg7->z = 1.0f;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
arg5->x = arg5->y = arg5->z = 0.0f;
|
|
arg6->x = arg6->y = arg6->z = 0.0f;
|
|
arg7->x = arg7->y = arg7->z = 1.0f;
|
|
}
|
|
|
|
u16 anim0002485c(s32 arg0, bool arg1, struct skeleton *skel, s16 animnum, s32 loopframe, s16 *arg5, bool arg6)
|
|
{
|
|
u16 result = 0;
|
|
s32 sum;
|
|
u8 sp2f;
|
|
u8 index;
|
|
u8 *sp28;
|
|
u8 *ptr;
|
|
s32 i;
|
|
|
|
if (arg6) {
|
|
arg5[0] = 0;
|
|
arg5[1] = 0;
|
|
arg5[2] = var8005f014[animnum];
|
|
} else {
|
|
anim00023d38(animnum);
|
|
index = anim00023ab0(animnum, loopframe);
|
|
anim00023d0c();
|
|
|
|
sp28 = var8009a874[index];
|
|
|
|
if (arg1) {
|
|
arg0 = skel->things[arg0][1];
|
|
}
|
|
|
|
// This is iterating the header information in the animation's data
|
|
sum = 0;
|
|
ptr = var8009a888[var8005f010[animnum]];
|
|
|
|
for (i = 0; i < arg0; i++) {
|
|
u8 flags = *ptr;
|
|
ptr++;
|
|
|
|
if (flags & 0x08) {
|
|
sum += ptr[2] + ptr[5] + ptr[8] + ptr[11];
|
|
ptr += 12;
|
|
} else if (flags & 0x02) {
|
|
sum += ptr[2] + ptr[5] + ptr[8];
|
|
ptr += 9;
|
|
} else if (flags & 0x20) {
|
|
sum += ptr[0] + ptr[5] + ptr[10];
|
|
ptr += 15;
|
|
}
|
|
|
|
if (flags & 0x01) {
|
|
sum += ptr[2] + ptr[5] + ptr[8];
|
|
ptr += 9;
|
|
} else if (flags & 0x10) {
|
|
sum += 96;
|
|
}
|
|
|
|
if (flags & 0x40) {
|
|
sum += *ptr;
|
|
ptr += 5;
|
|
}
|
|
|
|
if (flags & 0x80) {
|
|
sum += 96;
|
|
}
|
|
}
|
|
|
|
sp2f = ptr[3];
|
|
arg5[0] = anim00023fe0(sp28, sp2f, sum) + ptr[1] * 256 + ptr[2];
|
|
sum += sp2f;
|
|
|
|
sp2f = ptr[6];
|
|
arg5[1] = anim00023fe0(sp28, sp2f, sum) + ptr[4] * 256 + ptr[5];
|
|
sum += sp2f;
|
|
|
|
sp2f = ptr[9];
|
|
arg5[2] = anim00023fe0(sp28, sp2f, sum) + ptr[7] * 256 + ptr[8];
|
|
sum += sp2f;
|
|
|
|
sp2f = ptr[12];
|
|
result = anim00023fe0(sp28, sp2f, sum) + ptr[10] * 256 + ptr[11];
|
|
|
|
if (arg1) {
|
|
arg5[0] = -arg5[0];
|
|
|
|
if (result != 0) {
|
|
result = 0x10000 - result;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
f32 anim00024b64(u32 arg0, u32 arg1, struct skeleton *arg2, s16 animnum, u32 arg4, struct coord *coord, u32 arg6)
|
|
{
|
|
s16 sp30[3];
|
|
|
|
f32 value = anim0002485c(arg0, arg1, arg2, animnum, arg4, sp30, arg6);
|
|
|
|
coord->x = sp30[0];
|
|
coord->y = sp30[1];
|
|
coord->z = sp30[2];
|
|
|
|
return value * M_BADTAU / 65536.0f;
|
|
}
|
|
|
|
f32 anim00024c14(s32 arg0, s16 animnum, u8 arg2)
|
|
{
|
|
u32 stack[2];
|
|
u8 *sp24 = var8009a874[arg2];
|
|
u8 *ptr = var8009a888[var8005f010[animnum]];
|
|
f32 result = 0;
|
|
s32 total = 0;
|
|
s32 i;
|
|
u8 *end = ptr + g_Anims[animnum].headerlen;
|
|
|
|
for (i = 0; i < arg0 && ptr < end; i++) {
|
|
u8 flags = ptr[0];
|
|
ptr++;
|
|
|
|
if (flags & ANIMHEADERFLAG_08) {
|
|
total += ptr[2] + ptr[5] + ptr[8] + ptr[11];
|
|
ptr += 12;
|
|
} else if (flags & ANIMHEADERFLAG_02) {
|
|
total += ptr[2] + ptr[5] + ptr[8];
|
|
ptr += 9;
|
|
} else if (flags & ANIMHEADERFLAG_20) {
|
|
total += ptr[0] + ptr[5] + ptr[10];
|
|
ptr += 15;
|
|
}
|
|
|
|
if (flags & ANIMHEADERFLAG_01) {
|
|
total += ptr[2] + ptr[5] + ptr[8];
|
|
ptr += 9;
|
|
} else if (flags & ANIMHEADERFLAG_10) {
|
|
total += 0x60;
|
|
}
|
|
|
|
if (flags & ANIMHEADERFLAG_40) {
|
|
total += ptr[0];
|
|
ptr += 5;
|
|
}
|
|
|
|
if (flags & ANIMHEADERFLAG_80) {
|
|
total += 0x60;
|
|
}
|
|
}
|
|
|
|
if (ptr < end) {
|
|
u8 flags = ptr[0];
|
|
ptr++;
|
|
|
|
if (flags & ANIMHEADERFLAG_40) {
|
|
total = anim00023f50(sp24, ptr[0], total);
|
|
result = (total + ptr[1] * 0x1000000 + ptr[2] * 0x10000 + ptr[3] * 0x100 + ptr[4]) * 0.001f;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|