mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-21 07:37:45 -04:00
93afb02cf4
This includes all the collision stuff needed to spawn `target`, decompiles the sparticle code and adds some of the PC hacks needed for merc to run (it doesn't work quite right and looks bad, likely due to a combination of code copied from Jak 2 and the time of day hacks). There are a bunch of temporary hacks (see commits) in place to prevent the game from crashing quite as much, but it is still extremely prone to doing so due to lots of missing functions/potentially bad decomp. --------- Co-authored-by: water <awaterford111445@gmail.com>
1691 lines
91 KiB
C++
1691 lines
91 KiB
C++
// cppcheck-suppress-file unusedLabels
|
|
//--------------------------MIPS2C---------------------
|
|
// clang-format off
|
|
#include "game/mips2c/mips2c_private.h"
|
|
#include "game/kernel/jak3/kscheme.h"
|
|
using ::jak3::intern_from_c;
|
|
namespace Mips2C::jak3 {
|
|
namespace method_10_collide_edge_hold_list {
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
// bool bc = false;
|
|
u32 call_addr = 0;
|
|
bool cop1_bc = false;
|
|
// nop // sll r0, r0, 0
|
|
c->daddiu(a2, a0, 1552); // daddiu a2, a0, 1552
|
|
c->lwu(t0, 4, a0); // lwu t0, 4(a0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf1, 16, a1); // lqc2 vf1, 16(a1)
|
|
c->dsll(a3, t0, 4); // dsll a3, t0, 4
|
|
c->lwu(v1, 8, a0); // lwu v1, 8(a0)
|
|
c->daddiu(t0, t0, 1); // daddiu t0, t0, 1
|
|
c->lwc1(f0, 4, a1); // lwc1 f0, 4(a1)
|
|
c->daddu(a2, a2, a3); // daddu a2, a2, a3
|
|
c->sw(t0, 4, a0); // sw t0, 4(a0)
|
|
c->sqc2(vf1, 0, a2); // sqc2 vf1, 0(a2)
|
|
if (((s64)c->sgpr64(v1)) == ((s64)c->sgpr64(s7))) {// beql v1, s7, L96
|
|
c->sw(a1, 8, a0); // sw a1, 8(a0)
|
|
goto block_10;
|
|
}
|
|
|
|
// block_2:
|
|
c->lwc1(f1, 4, v1); // lwc1 f1, 4(v1)
|
|
cop1_bc = c->fprs[f0] < c->fprs[f1]; // c.lt.s f0, f1
|
|
if (cop1_bc) { // bc1tl L97
|
|
c->sw(a1, 8, a0); // sw a1, 8(a0)
|
|
goto block_11;
|
|
}
|
|
|
|
// block_4:
|
|
c->mov64(a0, v1); // or a0, v1, r0
|
|
|
|
block_5:
|
|
c->lwu(v1, 0, v1); // lwu v1, 0(v1)
|
|
if (((s64)c->sgpr64(v1)) == ((s64)c->sgpr64(s7))) {// beql v1, s7, L98
|
|
c->sw(a1, 0, a0); // sw a1, 0(a0)
|
|
goto block_12;
|
|
}
|
|
|
|
// block_7:
|
|
c->lwc1(f1, 4, v1); // lwc1 f1, 4(v1)
|
|
cop1_bc = c->fprs[f0] < c->fprs[f1]; // c.lt.s f0, f1
|
|
if (!cop1_bc) { // bc1fl L95
|
|
c->mov64(a0, v1); // or a0, v1, r0
|
|
goto block_5;
|
|
}
|
|
|
|
// block_9:
|
|
c->sw(a1, 0, a0); // sw a1, 0(a0)
|
|
//beq r0, r0, L99 // beq r0, r0, L99
|
|
c->sw(v1, 0, a1); // sw v1, 0(a1)
|
|
goto block_13; // branch always
|
|
|
|
|
|
block_10:
|
|
//beq r0, r0, L99 // beq r0, r0, L99
|
|
c->sw(s7, 0, a1); // sw s7, 0(a1)
|
|
goto block_13; // branch always
|
|
|
|
|
|
block_11:
|
|
//beq r0, r0, L99 // beq r0, r0, L99
|
|
c->sw(v1, 0, a1); // sw v1, 0(a1)
|
|
goto block_13; // branch always
|
|
|
|
|
|
block_12:
|
|
c->sw(s7, 0, a1); // sw s7, 0(a1)
|
|
|
|
block_13:
|
|
c->gprs[v0].du64[0] = 0; // or v0, r0, r0
|
|
//jr ra // jr ra
|
|
c->daddu(sp, sp, r0); // daddu sp, sp, r0
|
|
goto end_of_function; // return
|
|
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
gLinkedFunctionTable.reg("(method 10 collide-edge-hold-list)", execute, 256);
|
|
}
|
|
|
|
} // namespace method_10_collide_edge_hold_list
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
// clang-format off
|
|
#include "game/mips2c/mips2c_private.h"
|
|
#include "game/kernel/jak3/kscheme.h"
|
|
using ::jak3::intern_from_c;
|
|
namespace Mips2C::jak3 {
|
|
namespace method_19_collide_edge_work {
|
|
struct Cache {
|
|
void* collide_edge_hold_list; // collide-edge-hold-list
|
|
void* collide_edge_work; // collide-edge-work
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
u32 call_addr = 0;
|
|
c->daddiu(sp, sp, -176); // daddiu sp, sp, -176
|
|
c->sd(ra, 0, sp); // sd ra, 0(sp)
|
|
c->sq(s0, 64, sp); // sq s0, 64(sp)
|
|
c->sq(s1, 80, sp); // sq s1, 80(sp)
|
|
c->sq(s2, 96, sp); // sq s2, 96(sp)
|
|
c->sq(s3, 112, sp); // sq s3, 112(sp)
|
|
c->sq(s4, 128, sp); // sq s4, 128(sp)
|
|
c->sq(s5, 144, sp); // sq s5, 144(sp)
|
|
c->sq(gp, 160, sp); // sq gp, 160(sp)
|
|
c->mov64(gp, a0); // or gp, a0, r0
|
|
c->mov64(s5, a1); // or s5, a1, r0
|
|
c->mov64(s4, a2); // or s4, a2, r0
|
|
c->daddiu(s3, sp, 16); // daddiu s3, sp, 16
|
|
c->sd(r0, 256, s4); // sd r0, 256(s4)
|
|
c->addiu(s2, r0, 16); // addiu s2, r0, 16
|
|
|
|
block_1:
|
|
bc = c->sgpr64(s2) == 0; // beq s2, r0, L92
|
|
c->daddiu(s2, s2, -1); // daddiu s2, s2, -1
|
|
if (bc) {goto block_25;} // branch non-likely
|
|
|
|
c->lwu(s1, 8, s5); // lwu s1, 8(s5)
|
|
bc = c->sgpr64(s1) == c->sgpr64(s7); // beq s1, s7, L92
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_25;} // branch non-likely
|
|
|
|
c->mov64(a0, gp); // or a0, gp, r0
|
|
c->load_symbol2(v1, cache.collide_edge_work); // lw v1, collide-edge-work(s7)
|
|
c->lwu(t9, 96, v1); // lwu t9, 96(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
c->mov64(a2, s4); // or a2, s4, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
bc = c->sgpr64(v1) == c->sgpr64(s7); // beq v1, s7, L87
|
|
c->lwu(v1, 0, s1); // lwu v1, 0(s1)
|
|
if (bc) {goto block_5;} // branch non-likely
|
|
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, #t
|
|
c->mov64(v0, v1); // or v0, v1, r0
|
|
//beq r0, r0, L93 // beq r0, r0, L93
|
|
// nop // sll r0, r0, 0
|
|
goto block_26; // branch always
|
|
|
|
|
|
block_5:
|
|
c->lb(s0, 8, s1); // lb s0, 8(s1)
|
|
c->sw(v1, 8, s5); // sw v1, 8(s5)
|
|
bc = ((s64)c->sgpr64(s0)) > 0; // bgtz s0, L90
|
|
c->addiu(v1, r0, 2); // addiu v1, r0, 2
|
|
if (bc) {goto block_17;} // branch non-likely
|
|
|
|
if (((s64)c->sgpr64(s0)) < 0) { // bltzl s0, L91
|
|
c->dsubu(s0, r0, s0); // dsubu s0, r0, s0
|
|
goto block_21;
|
|
}
|
|
|
|
// block_8:
|
|
c->dsll(v1, s0, 2); // dsll v1, s0, 2
|
|
c->daddiu(a0, gp, 352); // daddiu a0, gp, 352
|
|
c->daddu(v1, a0, v1); // daddu v1, a0, v1
|
|
c->lw(v1, 0, v1); // lw v1, 0(v1)
|
|
c->mov128_vf_gpr(vf1, v1); // qmtc2.i vf1, v1
|
|
c->lwu(a2, 12, s1); // lwu a2, 12(s1)
|
|
c->vmove(DEST::xyzw, vf5, vf0); // vmove.xyzw vf5, vf0
|
|
c->lqc2(vf3, 16, s1); // lqc2 vf3, 16(s1)
|
|
c->vmove(DEST::xyzw, vf6, vf0); // vmove.xyzw vf6, vf0
|
|
c->lqc2(vf4, 32, a2); // lqc2 vf4, 32(a2)
|
|
c->lwu(v1, 12, a2); // lwu v1, 12(a2)
|
|
c->vmul_bc(DEST::xyz, BC::x, vf2, vf4, vf1); // vmulx.xyz vf2, vf4, vf1
|
|
c->vadd(DEST::xyz, vf5, vf3, vf2); // vadd.xyz vf5, vf3, vf2
|
|
c->vsub(DEST::xyz, vf6, vf3, vf2); // vsub.xyz vf6, vf3, vf2
|
|
c->lqc2(vf8, 0, v1); // lqc2 vf8, 0(v1)
|
|
c->sqc2(vf6, 16, s3); // sqc2 vf6, 16(s3)
|
|
c->sqc2(vf2, 32, s3); // sqc2 vf2, 32(s3)
|
|
c->sw(a2, 0, s3); // sw a2, 0(s3)
|
|
c->sw(s7, 4, s3); // sw s7, 4(s3)
|
|
c->vsub(DEST::xyz, vf9, vf8, vf5); // vsub.xyz vf9, vf8, vf5
|
|
c->vmul(DEST::xyz, vf9, vf9, vf2); // vmul.xyz vf9, vf9, vf2
|
|
c->vadd_bc(DEST::x, BC::y, vf9, vf9, vf9); // vaddy.x vf9, vf9, vf9
|
|
c->vadd_bc(DEST::x, BC::z, vf9, vf9, vf9); // vaddz.x vf9, vf9, vf9
|
|
c->mov128_gpr_vf(v1, vf9); // qmfc2.i v1, vf9
|
|
bc = ((s64)c->sgpr64(v1)) < 0; // bltz v1, L88
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_12;} // branch non-likely
|
|
|
|
c->sqc2(vf5, 16, s1); // sqc2 vf5, 16(s1)
|
|
c->mov64(a0, gp); // or a0, gp, r0
|
|
c->load_symbol2(v1, cache.collide_edge_work); // lw v1, collide-edge-work(s7)
|
|
c->lwu(t9, 88, v1); // lwu t9, 88(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
bc = c->sgpr64(v1) == c->sgpr64(s7); // beq v1, s7, L88
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_12;} // branch non-likely
|
|
|
|
c->mov64(a0, s5); // or a0, s5, r0
|
|
c->load_symbol2(v1, cache.collide_edge_hold_list);// lw v1, collide-edge-hold-list(s7)
|
|
c->lwu(t9, 56, v1); // lwu t9, 56(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
c->addiu(v1, r0, 1); // addiu v1, r0, 1
|
|
c->sb(v1, 8, s1); // sb v1, 8(s1)
|
|
c->addiu(v1, r0, 32); // addiu v1, r0, 32
|
|
c->lwu(a0, 0, s5); // lwu a0, 0(s5)
|
|
c->addiu(a1, r0, 48); // addiu a1, r0, 48
|
|
bc = c->sgpr64(a0) == c->sgpr64(v1); // beq a0, v1, L86
|
|
c->mult3(v1, a0, a1); // mult3 v1, a0, a1
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->daddu(v1, v1, s5); // daddu v1, v1, s5
|
|
c->sw(r0, 4, s3); // sw r0, 4(s3)
|
|
c->daddiu(s1, v1, 16); // daddiu s1, v1, 16
|
|
|
|
block_12:
|
|
c->lwu(a2, 0, s3); // lwu a2, 0(s3)
|
|
c->lqc2(vf6, 16, s3); // lqc2 vf6, 16(s3)
|
|
c->lqc2(vf2, 32, s3); // lqc2 vf2, 32(s3)
|
|
c->lwu(v1, 8, a2); // lwu v1, 8(a2)
|
|
c->lqc2(vf7, 0, v1); // lqc2 vf7, 0(v1)
|
|
c->vsub(DEST::xyz, vf9, vf6, vf7); // vsub.xyz vf9, vf6, vf7
|
|
c->vmul(DEST::xyz, vf9, vf9, vf2); // vmul.xyz vf9, vf9, vf2
|
|
c->vadd_bc(DEST::x, BC::y, vf9, vf9, vf9); // vaddy.x vf9, vf9, vf9
|
|
c->vadd_bc(DEST::x, BC::z, vf9, vf9, vf9); // vaddz.x vf9, vf9, vf9
|
|
c->mov128_gpr_vf(v1, vf9); // qmfc2.i v1, vf9
|
|
bc = ((s64)c->sgpr64(v1)) < 0; // bltz v1, L86
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->sqc2(vf6, 16, s1); // sqc2 vf6, 16(s1)
|
|
c->mov64(a0, gp); // or a0, gp, r0
|
|
c->load_symbol2(v1, cache.collide_edge_work); // lw v1, collide-edge-work(s7)
|
|
c->lwu(t9, 88, v1); // lwu t9, 88(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
bc = c->sgpr64(v1) == c->sgpr64(s7); // beq v1, s7, L86
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->mov64(a0, s5); // or a0, s5, r0
|
|
c->load_symbol2(v1, cache.collide_edge_hold_list);// lw v1, collide-edge-hold-list(s7)
|
|
c->lwu(t9, 56, v1); // lwu t9, 56(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
c->lwu(v1, 4, s3); // lwu v1, 4(s3)
|
|
bc = c->sgpr64(v1) == c->sgpr64(s7); // beq v1, s7, L89
|
|
c->lwu(v1, 0, s5); // lwu v1, 0(s5)
|
|
if (bc) {goto block_16;} // branch non-likely
|
|
|
|
c->daddiu(v1, v1, 1); // daddiu v1, v1, 1
|
|
c->sw(v1, 0, s5); // sw v1, 0(s5)
|
|
|
|
block_16:
|
|
c->addiu(v1, r0, -1); // addiu v1, r0, -1
|
|
//beq r0, r0, L86 // beq r0, r0, L86
|
|
c->sb(v1, 8, s1); // sb v1, 8(s1)
|
|
goto block_1; // branch always
|
|
|
|
|
|
block_17:
|
|
bc = c->sgpr64(s0) == c->sgpr64(v1); // beq s0, v1, L86
|
|
c->lwu(a2, 12, s1); // lwu a2, 12(s1)
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->dsll(v1, s0, 2); // dsll v1, s0, 2
|
|
c->daddiu(a0, gp, 352); // daddiu a0, gp, 352
|
|
c->daddu(v1, a0, v1); // daddu v1, a0, v1
|
|
c->lw(v1, 0, v1); // lw v1, 0(v1)
|
|
c->mov128_vf_gpr(vf1, v1); // qmtc2.i vf1, v1
|
|
c->lqc2(vf3, 16, s1); // lqc2 vf3, 16(s1)
|
|
c->vmove(DEST::xyzw, vf5, vf0); // vmove.xyzw vf5, vf0
|
|
c->lqc2(vf4, 32, a2); // lqc2 vf4, 32(a2)
|
|
c->lwu(v1, 12, a2); // lwu v1, 12(a2)
|
|
c->vmul_bc(DEST::xyz, BC::x, vf2, vf4, vf1); // vmulx.xyz vf2, vf4, vf1
|
|
c->vadd(DEST::xyz, vf5, vf3, vf2); // vadd.xyz vf5, vf3, vf2
|
|
c->lqc2(vf8, 0, v1); // lqc2 vf8, 0(v1)
|
|
c->vsub(DEST::xyz, vf9, vf8, vf5); // vsub.xyz vf9, vf8, vf5
|
|
c->vmul(DEST::xyz, vf9, vf9, vf2); // vmul.xyz vf9, vf9, vf2
|
|
c->vadd_bc(DEST::x, BC::y, vf9, vf9, vf9); // vaddy.x vf9, vf9, vf9
|
|
c->vadd_bc(DEST::x, BC::z, vf9, vf9, vf9); // vaddz.x vf9, vf9, vf9
|
|
c->mov128_gpr_vf(v1, vf9); // qmfc2.i v1, vf9
|
|
bc = ((s64)c->sgpr64(v1)) < 0; // bltz v1, L86
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->sqc2(vf5, 16, s1); // sqc2 vf5, 16(s1)
|
|
c->mov64(a0, gp); // or a0, gp, r0
|
|
c->load_symbol2(v1, cache.collide_edge_work); // lw v1, collide-edge-work(s7)
|
|
c->lwu(t9, 88, v1); // lwu t9, 88(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
bc = c->sgpr64(v1) == c->sgpr64(s7); // beq v1, s7, L86
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->mov64(a0, s5); // or a0, s5, r0
|
|
c->load_symbol2(v1, cache.collide_edge_hold_list);// lw v1, collide-edge-hold-list(s7)
|
|
c->lwu(t9, 56, v1); // lwu t9, 56(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
c->daddiu(v1, s0, 1); // daddiu v1, s0, 1
|
|
//beq r0, r0, L86 // beq r0, r0, L86
|
|
c->sb(v1, 8, s1); // sb v1, 8(s1)
|
|
goto block_1; // branch always
|
|
|
|
|
|
block_21:
|
|
bc = c->sgpr64(s0) == c->sgpr64(v1); // beq s0, v1, L86
|
|
c->lwu(a2, 12, s1); // lwu a2, 12(s1)
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->dsll(v1, s0, 2); // dsll v1, s0, 2
|
|
c->daddiu(a0, gp, 352); // daddiu a0, gp, 352
|
|
c->daddu(v1, a0, v1); // daddu v1, a0, v1
|
|
c->lw(v1, 0, v1); // lw v1, 0(v1)
|
|
c->mov128_vf_gpr(vf1, v1); // qmtc2.i vf1, v1
|
|
c->lqc2(vf3, 16, s1); // lqc2 vf3, 16(s1)
|
|
c->vmove(DEST::xyzw, vf6, vf0); // vmove.xyzw vf6, vf0
|
|
c->lqc2(vf4, 32, a2); // lqc2 vf4, 32(a2)
|
|
c->lwu(v1, 8, a2); // lwu v1, 8(a2)
|
|
c->vmul_bc(DEST::xyz, BC::x, vf2, vf4, vf1); // vmulx.xyz vf2, vf4, vf1
|
|
c->vsub(DEST::xyz, vf6, vf3, vf2); // vsub.xyz vf6, vf3, vf2
|
|
c->lqc2(vf7, 0, v1); // lqc2 vf7, 0(v1)
|
|
c->vsub(DEST::xyz, vf9, vf6, vf7); // vsub.xyz vf9, vf6, vf7
|
|
c->vmul(DEST::xyz, vf9, vf9, vf2); // vmul.xyz vf9, vf9, vf2
|
|
c->vadd_bc(DEST::x, BC::y, vf9, vf9, vf9); // vaddy.x vf9, vf9, vf9
|
|
c->vadd_bc(DEST::x, BC::z, vf9, vf9, vf9); // vaddz.x vf9, vf9, vf9
|
|
c->mov128_gpr_vf(v1, vf9); // qmfc2.i v1, vf9
|
|
bc = ((s64)c->sgpr64(v1)) < 0; // bltz v1, L86
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->sqc2(vf6, 16, s1); // sqc2 vf6, 16(s1)
|
|
c->mov64(a0, gp); // or a0, gp, r0
|
|
c->load_symbol2(v1, cache.collide_edge_work); // lw v1, collide-edge-work(s7)
|
|
c->lwu(t9, 88, v1); // lwu t9, 88(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
bc = c->sgpr64(v1) == c->sgpr64(s7); // beq v1, s7, L86
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->mov64(a0, s5); // or a0, s5, r0
|
|
c->load_symbol2(v1, cache.collide_edge_hold_list);// lw v1, collide-edge-hold-list(s7)
|
|
c->lwu(t9, 56, v1); // lwu t9, 56(v1)
|
|
c->mov64(a1, s1); // or a1, s1, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
c->daddiu(v1, s0, 1); // daddiu v1, s0, 1
|
|
c->dsubu(v1, r0, v1); // dsubu v1, r0, v1
|
|
//beq r0, r0, L86 // beq r0, r0, L86
|
|
c->sb(v1, 8, s1); // sb v1, 8(s1)
|
|
goto block_1; // branch always
|
|
|
|
|
|
block_25:
|
|
c->mov64(v0, s7); // or v0, s7, r0
|
|
|
|
block_26:
|
|
c->ld(ra, 0, sp); // ld ra, 0(sp)
|
|
c->lq(gp, 160, sp); // lq gp, 160(sp)
|
|
c->lq(s5, 144, sp); // lq s5, 144(sp)
|
|
c->lq(s4, 128, sp); // lq s4, 128(sp)
|
|
c->lq(s3, 112, sp); // lq s3, 112(sp)
|
|
c->lq(s2, 96, sp); // lq s2, 96(sp)
|
|
c->lq(s1, 80, sp); // lq s1, 80(sp)
|
|
c->lq(s0, 64, sp); // lq s0, 64(sp)
|
|
//jr ra // jr ra
|
|
c->daddiu(sp, sp, 176); // daddiu sp, sp, 176
|
|
goto end_of_function; // return
|
|
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.collide_edge_hold_list = intern_from_c(-1, 0, "collide-edge-hold-list").c();
|
|
cache.collide_edge_work = intern_from_c(-1, 0, "collide-edge-work").c();
|
|
gLinkedFunctionTable.reg("(method 19 collide-edge-work)", execute, 256);
|
|
}
|
|
|
|
} // namespace method_19_collide_edge_work
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
// clang-format off
|
|
#include "game/mips2c/mips2c_private.h"
|
|
#include "game/kernel/jak3/kscheme.h"
|
|
using ::jak3::intern_from_c;
|
|
namespace Mips2C::jak3 {
|
|
namespace method_9_edge_grab_info {
|
|
struct Cache {
|
|
void* collide_cache; // *collide-cache*
|
|
void* collide_edge_work; // *collide-edge-work*
|
|
void* target; // *target*
|
|
void* edge_grabbed; // edge-grabbed
|
|
void* matrix; // matrix
|
|
void* send_event_function; // send-event-function
|
|
void* target_edge_grab_jump; // target-edge-grab-jump
|
|
void* vector_matrix; // vector-matrix*!
|
|
void* vector_normalize; // vector-normalize!
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
u32 call_addr = 0;
|
|
bool cop1_bc = false;
|
|
c->daddiu(sp, sp, -704); // daddiu sp, sp, -704
|
|
c->sd(ra, 0, sp); // sd ra, 0(sp)
|
|
c->sq(s3, 640, sp); // sq s3, 640(sp)
|
|
c->sq(s4, 656, sp); // sq s4, 656(sp)
|
|
c->sq(s5, 672, sp); // sq s5, 672(sp)
|
|
c->sq(gp, 688, sp); // sq gp, 688(sp)
|
|
c->mov64(gp, a0); // or gp, a0, r0
|
|
c->mov64(s5, s7); // or s5, s7, r0
|
|
c->daddiu(v1, gp, 384); // daddiu v1, gp, 384
|
|
c->daddiu(a0, gp, 32); // daddiu a0, gp, 32
|
|
c->lq(a0, 0, a0); // lq a0, 0(a0)
|
|
c->sq(a0, 0, v1); // sq a0, 0(v1)
|
|
c->lw(v1, 264, gp); // lw v1, 264(gp)
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L46
|
|
c->mov64(a0, s7); // or a0, s7, r0
|
|
if (bc) {goto block_18;} // branch non-likely
|
|
|
|
c->ld(a0, 272, gp); // ld a0, 272(gp)
|
|
c->subu(a1, a0, s7); // subu a1, a0, s7
|
|
if (((s64)c->sgpr64(a1)) == ((s64)0)) { // beql a1, r0, L40
|
|
c->mov64(a0, s7); // or a0, s7, r0
|
|
goto block_6;
|
|
}
|
|
|
|
// block_3:
|
|
c->sllv(a1, a0, r0); // sllv a1, a0, r0
|
|
c->lwu(a1, 0, a1); // lwu a1, 0(a1)
|
|
c->lw(a2, 40, a1); // lw a2, 40(a1)
|
|
c->dsra32(a0, a0, 0); // dsra32 a0, a0, 0
|
|
bc = c->sgpr64(a0) != c->sgpr64(a2); // bne a0, a2, L39
|
|
c->mov64(a0, s7); // or a0, s7, r0
|
|
if (bc) {goto block_5;} // branch non-likely
|
|
|
|
c->mov64(a0, a1); // or a0, a1, r0
|
|
|
|
block_5:
|
|
c->mov64(a1, a0); // or a1, a0, r0
|
|
|
|
block_6:
|
|
bc = c->sgpr64(s7) != c->sgpr64(a0); // bne s7, a0, L41
|
|
c->mov64(a1, s7); // or a1, s7, r0
|
|
if (bc) {goto block_9;} // branch non-likely
|
|
|
|
c->mov64(v0, s7); // or v0, s7, r0
|
|
//beq r0, r0, L54 // beq r0, r0, L54
|
|
// nop // sll r0, r0, 0
|
|
goto block_34; // branch always
|
|
|
|
c->gprs[v1].du64[0] = 0; // or v1, r0, r0
|
|
|
|
block_9:
|
|
c->daddu(s5, a0, v1); // daddu s5, a0, v1
|
|
c->lwu(v1, 28, s5); // lwu v1, 28(s5)
|
|
bc = c->sgpr64(v1) != 0; // bne v1, r0, L42
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_12;} // branch non-likely
|
|
|
|
c->mov64(v0, s7); // or v0, s7, r0
|
|
//beq r0, r0, L54 // beq r0, r0, L54
|
|
// nop // sll r0, r0, 0
|
|
goto block_34; // branch always
|
|
|
|
c->gprs[v1].du64[0] = 0; // or v1, r0, r0
|
|
|
|
block_12:
|
|
c->lwu(v1, 128, a0); // lwu v1, 128(a0)
|
|
c->lb(a0, 8, s5); // lb a0, 8(s5)
|
|
c->dsll(a0, a0, 5); // dsll a0, a0, 5
|
|
c->daddu(v1, v1, a0); // daddu v1, v1, a0
|
|
c->lwu(v1, 28, v1); // lwu v1, 28(v1)
|
|
c->daddu(s4, r0, v1); // daddu s4, r0, v1
|
|
c->addiu(s3, r0, 0); // addiu s3, r0, 0
|
|
//beq r0, r0, L44 // beq r0, r0, L44
|
|
// nop // sll r0, r0, 0
|
|
goto block_14; // branch always
|
|
|
|
|
|
block_13:
|
|
c->load_symbol2(t9, cache.vector_matrix); // lw t9, vector-matrix*!(s7)
|
|
c->dsll(v1, s3, 4); // dsll v1, s3, 4
|
|
c->daddu(v1, r0, v1); // daddu v1, r0, v1
|
|
c->daddu(a0, v1, gp); // daddu a0, v1, gp
|
|
c->dsll(v1, s3, 4); // dsll v1, s3, 4
|
|
c->daddiu(v1, v1, 128); // daddiu v1, v1, 128
|
|
c->daddu(a1, v1, gp); // daddu a1, v1, gp
|
|
c->mov64(a2, s4); // or a2, s4, r0
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->daddiu(s3, s3, 1); // daddiu s3, s3, 1
|
|
|
|
block_14:
|
|
c->slti(v1, s3, 8); // slti v1, s3, 8
|
|
bc = c->sgpr64(v1) != 0; // bne v1, r0, L43
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_13;} // branch non-likely
|
|
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
c->lqc2(vf1, 48, gp); // lqc2 vf1, 48(gp)
|
|
c->lqc2(vf2, 64, gp); // lqc2 vf2, 64(gp)
|
|
c->lqc2(vf3, 80, gp); // lqc2 vf3, 80(gp)
|
|
c->vsub(DEST::xyzw, vf4, vf2, vf1); // vsub.xyzw vf4, vf2, vf1
|
|
c->vsub(DEST::xyzw, vf5, vf3, vf1); // vsub.xyzw vf5, vf3, vf1
|
|
c->vopmula(vf4, vf5); // vopmula.xyz acc, vf4, vf5
|
|
c->vopmsub(vf6, vf5, vf4); // vopmsub.xyz vf6, vf5, vf4
|
|
c->vmul(DEST::xyzw, vf7, vf6, vf6); // vmul.xyzw vf7, vf6, vf6
|
|
c->vmula_bc(DEST::w, BC::x, vf0, vf7); // vmulax.w acc, vf0, vf7
|
|
c->vmadda_bc(DEST::w, BC::y, vf0, vf7); // vmadday.w acc, vf0, vf7
|
|
c->vmadd_bc(DEST::w, BC::z, vf7, vf0, vf7); // vmaddz.w vf7, vf0, vf7
|
|
c->vrsqrt(vf0, BC::w, vf7, BC::w); // vrsqrt Q, vf0.w, vf7.w
|
|
c->lui(v1, 16180); // lui v1, 16180
|
|
c->ori(v1, v1, 65012); // ori v1, v1, 65012
|
|
c->mtc1(f1, v1); // mtc1 f1, v1
|
|
c->vwaitq(); // vwaitq
|
|
// nop // sll r0, r0, 0
|
|
c->vmulq(DEST::xyz, vf6, vf6); // vmulq.xyz vf6, vf6, Q
|
|
c->mov128_gpr_vf(v1, vf6); // qmfc2.i v1, vf6
|
|
c->dsra32(v1, v1, 0); // dsra32 v1, v1, 0
|
|
c->mtc1(f2, v1); // mtc1 f2, v1
|
|
cop1_bc = c->fprs[f2] < c->fprs[f1]; // c.lt.s f2, f1
|
|
bc = !cop1_bc; // bc1f L45
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_17;} // branch non-likely
|
|
|
|
c->mov64(v0, s7); // or v0, s7, r0
|
|
//beq r0, r0, L54 // beq r0, r0, L54
|
|
// nop // sll r0, r0, 0
|
|
goto block_34; // branch always
|
|
|
|
|
|
block_17:
|
|
c->daddiu(v1, gp, 304); // daddiu v1, gp, 304
|
|
c->load_symbol2(a0, cache.target); // lw a0, *target*(s7)
|
|
c->lwu(a0, 124, a0); // lwu a0, 124(a0)
|
|
c->lwu(a0, 464, a0); // lwu a0, 464(a0)
|
|
c->daddiu(a0, a0, 28); // daddiu a0, a0, 28
|
|
c->lq(a0, 0, a0); // lq a0, 0(a0)
|
|
c->sq(a0, 0, v1); // sq a0, 0(v1)
|
|
c->load_symbol2(t9, cache.vector_normalize); // lw t9, vector-normalize!(s7)
|
|
c->daddiu(a0, gp, 320); // daddiu a0, gp, 320
|
|
c->daddiu(v1, gp, 16); // daddiu v1, gp, 16
|
|
c->daddu(a1, r0, gp); // daddu a1, r0, gp
|
|
c->lqc2(vf4, 0, v1); // lqc2 vf4, 0(v1)
|
|
c->lqc2(vf5, 0, a1); // lqc2 vf5, 0(a1)
|
|
c->vmove(DEST::w, vf6, vf0); // vmove.w vf6, vf0
|
|
c->vsub(DEST::xyz, vf6, vf4, vf5); // vsub.xyz vf6, vf4, vf5
|
|
c->sqc2(vf6, 0, a0); // sqc2 vf6, 0(a0)
|
|
c->lui(a1, 16256); // lui a1, 16256
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->load_symbol2(t9, cache.vector_normalize); // lw t9, vector-normalize!(s7)
|
|
c->daddiu(a0, gp, 288); // daddiu a0, gp, 288
|
|
c->daddiu(v1, gp, 320); // daddiu v1, gp, 320
|
|
c->daddiu(a1, gp, 304); // daddiu a1, gp, 304
|
|
c->lqc2(vf1, 0, v1); // lqc2 vf1, 0(v1)
|
|
c->lqc2(vf2, 0, a1); // lqc2 vf2, 0(a1)
|
|
c->vopmula(vf1, vf2); // vopmula.xyz acc, vf1, vf2
|
|
c->vopmsub(vf3, vf2, vf1); // vopmsub.xyz vf3, vf2, vf1
|
|
c->sqc2(vf3, 0, a0); // sqc2 vf3, 0(a0)
|
|
c->lui(a1, 16256); // lui a1, 16256
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->daddiu(a1, gp, 320); // daddiu a1, gp, 320
|
|
c->daddiu(v1, gp, 288); // daddiu v1, gp, 288
|
|
c->daddiu(a0, gp, 304); // daddiu a0, gp, 304
|
|
c->lqc2(vf1, 0, v1); // lqc2 vf1, 0(v1)
|
|
c->lqc2(vf2, 0, a0); // lqc2 vf2, 0(a0)
|
|
c->vopmula(vf1, vf2); // vopmula.xyz acc, vf1, vf2
|
|
c->vopmsub(vf3, vf2, vf1); // vopmsub.xyz vf3, vf2, vf1
|
|
c->sqc2(vf3, 0, a1); // sqc2 vf3, 0(a1)
|
|
c->daddiu(v1, gp, 336); // daddiu v1, gp, 336
|
|
c->daddiu(a0, gp, 32); // daddiu a0, gp, 32
|
|
c->lq(a0, 0, a0); // lq a0, 0(a0)
|
|
c->sq(a0, 0, v1); // sq a0, 0(v1)
|
|
c->load_symbol2(v1, cache.collide_edge_work); // lw v1, *collide-edge-work*(s7)
|
|
c->daddiu(a0, gp, 288); // daddiu a0, gp, 288
|
|
c->load_symbol2(a1, cache.matrix); // lw a1, matrix(s7)
|
|
c->lwu(t9, 52, a1); // lwu t9, 52(a1)
|
|
c->daddiu(a1, v1, 160); // daddiu a1, v1, 160
|
|
c->daddiu(a2, v1, 480); // daddiu a2, v1, 480
|
|
c->addiu(a3, r0, 12); // addiu a3, r0, 12
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(a0, v0); // or a0, v0, r0
|
|
|
|
block_18:
|
|
c->load_symbol2(v1, cache.collide_edge_work); // lw v1, *collide-edge-work*(s7)
|
|
c->daddiu(a1, sp, 16); // daddiu a1, sp, 16
|
|
c->lui(a0, 4); // lui a0, 4
|
|
c->load_symbol2(a2, cache.target); // lw a2, *target*(s7)
|
|
c->ld(a2, 196, a2); // ld a2, 196(a2)
|
|
c->and_(a0, a0, a2); // and a0, a0, a2
|
|
bc = c->sgpr64(a0) == 0; // beq a0, r0, L47
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_20;} // branch non-likely
|
|
|
|
c->mov64(a0, a1); // or a0, a1, r0
|
|
c->daddiu(a2, v1, 160); // daddiu a2, v1, 160
|
|
c->sw(a2, 112, a0); // sw a2, 112(a0)
|
|
c->addiu(a2, r0, 6); // addiu a2, r0, 6
|
|
c->sw(a2, 116, a0); // sw a2, 116(a0)
|
|
c->lwu(v1, 4, v1); // lwu v1, 4(v1)
|
|
c->lwu(v1, 156, v1); // lwu v1, 156(v1)
|
|
c->lwu(v1, 32, v1); // lwu v1, 32(v1)
|
|
c->sw(v1, 100, a0); // sw v1, 100(a0)
|
|
c->sw(s7, 88, a0); // sw s7, 88(a0)
|
|
c->sw(s7, 92, a0); // sw s7, 92(a0)
|
|
c->lui(v1, 2304); // lui v1, 2304
|
|
c->ori(v1, v1, 17); // ori v1, v1, 17
|
|
c->sw(v1, 96, a0); // sw v1, 96(a0)
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, #t
|
|
c->sw(v1, 120, a0); // sw v1, 120(a0)
|
|
c->addiu(v1, r0, 1); // addiu v1, r0, 1
|
|
c->sw(v1, 352, a0); // sw v1, 352(a0)
|
|
//beq r0, r0, L50 // beq r0, r0, L50
|
|
// nop // sll r0, r0, 0
|
|
goto block_26; // branch always
|
|
|
|
|
|
block_20:
|
|
c->load_symbol2(a0, cache.target); // lw a0, *target*(s7)
|
|
c->lwu(a0, 68, a0); // lwu a0, 68(a0)
|
|
if (((s64)c->sgpr64(s7)) == ((s64)c->sgpr64(a0))) {// beql s7, a0, L48
|
|
c->mov64(a0, a0); // or a0, a0, r0
|
|
goto block_23;
|
|
}
|
|
|
|
// block_22:
|
|
c->load_symbol2(a0, cache.target); // lw a0, *target*(s7)
|
|
c->lwu(a0, 68, a0); // lwu a0, 68(a0)
|
|
c->lwu(a0, 0, a0); // lwu a0, 0(a0)
|
|
c->load_symbol_addr(a2, cache.target_edge_grab_jump);// daddiu a2, s7, target-edge-grab-jump
|
|
c->dsubu(a2, a0, a2); // dsubu a2, a0, a2
|
|
c->daddiu(a0, s7, 4); // daddiu a0, s7, 4
|
|
c->movn(a0, s7, a2); // movn a0, s7, a2
|
|
|
|
block_23:
|
|
bc = c->sgpr64(s7) == c->sgpr64(a0); // beq s7, a0, L49
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_25;} // branch non-likely
|
|
|
|
c->mov64(a0, a1); // or a0, a1, r0
|
|
c->daddiu(a2, v1, 256); // daddiu a2, v1, 256
|
|
c->sw(a2, 112, a0); // sw a2, 112(a0)
|
|
c->addiu(a2, r0, 6); // addiu a2, r0, 6
|
|
c->sw(a2, 116, a0); // sw a2, 116(a0)
|
|
c->lwu(v1, 4, v1); // lwu v1, 4(v1)
|
|
c->lwu(v1, 156, v1); // lwu v1, 156(v1)
|
|
c->lwu(v1, 32, v1); // lwu v1, 32(v1)
|
|
c->sw(v1, 100, a0); // sw v1, 100(a0)
|
|
c->sw(s7, 88, a0); // sw s7, 88(a0)
|
|
c->sw(s7, 92, a0); // sw s7, 92(a0)
|
|
c->lui(v1, 2304); // lui v1, 2304
|
|
c->ori(v1, v1, 17); // ori v1, v1, 17
|
|
c->sw(v1, 96, a0); // sw v1, 96(a0)
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, #t
|
|
c->sw(v1, 120, a0); // sw v1, 120(a0)
|
|
c->addiu(v1, r0, 1); // addiu v1, r0, 1
|
|
c->sw(v1, 352, a0); // sw v1, 352(a0)
|
|
//beq r0, r0, L50 // beq r0, r0, L50
|
|
// nop // sll r0, r0, 0
|
|
goto block_26; // branch always
|
|
|
|
|
|
block_25:
|
|
c->mov64(a0, a1); // or a0, a1, r0
|
|
c->daddiu(a2, v1, 160); // daddiu a2, v1, 160
|
|
c->sw(a2, 112, a0); // sw a2, 112(a0)
|
|
c->addiu(a2, r0, 6); // addiu a2, r0, 6
|
|
c->sw(a2, 116, a0); // sw a2, 116(a0)
|
|
c->lwu(v1, 4, v1); // lwu v1, 4(v1)
|
|
c->lwu(v1, 156, v1); // lwu v1, 156(v1)
|
|
c->lwu(v1, 32, v1); // lwu v1, 32(v1)
|
|
c->sw(v1, 100, a0); // sw v1, 100(a0)
|
|
c->sw(s7, 88, a0); // sw s7, 88(a0)
|
|
c->sw(s7, 92, a0); // sw s7, 92(a0)
|
|
c->lui(v1, 2304); // lui v1, 2304
|
|
c->ori(v1, v1, 17); // ori v1, v1, 17
|
|
c->sw(v1, 96, a0); // sw v1, 96(a0)
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, #t
|
|
c->sw(v1, 120, a0); // sw v1, 120(a0)
|
|
c->addiu(v1, r0, 1); // addiu v1, r0, 1
|
|
c->sw(v1, 352, a0); // sw v1, 352(a0)
|
|
|
|
block_26:
|
|
c->load_symbol2(a0, cache.collide_cache); // lw a0, *collide-cache*(s7)
|
|
c->lwu(v1, -4, a0); // lwu v1, -4(a0)
|
|
c->lwu(t9, 60, v1); // lwu t9, 60(v1)
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
bc = c->sgpr64(s7) == c->sgpr64(v1); // beq s7, v1, L51
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_29;} // branch non-likely
|
|
|
|
c->mov64(v0, s7); // or v0, s7, r0
|
|
//beq r0, r0, L54 // beq r0, r0, L54
|
|
// nop // sll r0, r0, 0
|
|
goto block_34; // branch always
|
|
|
|
c->gprs[v1].du64[0] = 0; // or v1, r0, r0
|
|
|
|
block_29:
|
|
bc = c->sgpr64(s7) == c->sgpr64(s5); // beq s7, s5, L53
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_33;} // branch non-likely
|
|
|
|
c->lwu(v1, 0, s5); // lwu v1, 0(s5)
|
|
c->daddiu(a1, sp, 560); // daddiu a1, sp, 560
|
|
c->mov64(a0, s6); // or a0, s6, r0
|
|
bc = c->sgpr64(s7) == c->sgpr64(a0); // beq s7, a0, L52
|
|
c->mov64(a2, s7); // or a2, s7, r0
|
|
if (bc) {goto block_32;} // branch non-likely
|
|
|
|
c->lwu(a2, 24, a0); // lwu a2, 24(a0)
|
|
|
|
block_32:
|
|
c->sw(a2, 8, a1); // sw a2, 8(a1)
|
|
c->addiu(a0, r0, 1); // addiu a0, r0, 1
|
|
c->sw(a0, 68, a1); // sw a0, 68(a1)
|
|
c->load_symbol_addr(a0, cache.edge_grabbed); // daddiu a0, s7, edge-grabbed
|
|
c->sw(a0, 64, a1); // sw a0, 64(a1)
|
|
c->sd(gp, 16, a1); // sd gp, 16(a1)
|
|
c->load_symbol2(t9, cache.send_event_function); // lw t9, send-event-function(s7)
|
|
c->lwu(a0, 136, v1); // lwu a0, 136(v1)
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
|
|
block_33:
|
|
c->daddiu(v0, s7, 4); // daddiu v0, s7, #t
|
|
|
|
block_34:
|
|
c->ld(ra, 0, sp); // ld ra, 0(sp)
|
|
c->lq(gp, 688, sp); // lq gp, 688(sp)
|
|
c->lq(s5, 672, sp); // lq s5, 672(sp)
|
|
c->lq(s4, 656, sp); // lq s4, 656(sp)
|
|
c->lq(s3, 640, sp); // lq s3, 640(sp)
|
|
//jr ra // jr ra
|
|
c->daddiu(sp, sp, 704); // daddiu sp, sp, 704
|
|
goto end_of_function; // return
|
|
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.collide_cache = intern_from_c(-1, 0, "*collide-cache*").c();
|
|
cache.collide_edge_work = intern_from_c(-1, 0, "*collide-edge-work*").c();
|
|
cache.target = intern_from_c(-1, 0, "*target*").c();
|
|
cache.edge_grabbed = intern_from_c(-1, 0, "edge-grabbed").c();
|
|
cache.matrix = intern_from_c(-1, 0, "matrix").c();
|
|
cache.send_event_function = intern_from_c(-1, 0, "send-event-function").c();
|
|
cache.target_edge_grab_jump = intern_from_c(-1, 0, "target-edge-grab-jump").c();
|
|
cache.vector_matrix = intern_from_c(-1, 0, "vector-matrix*!").c();
|
|
cache.vector_normalize = intern_from_c(-1, 0, "vector-normalize!").c();
|
|
gLinkedFunctionTable.reg("(method 9 edge-grab-info)", execute, 1024);
|
|
}
|
|
|
|
} // namespace method_9_edge_grab_info
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
// clang-format off
|
|
#include "game/mips2c/mips2c_private.h"
|
|
#include "game/kernel/jak3/kscheme.h"
|
|
using ::jak3::intern_from_c;
|
|
namespace Mips2C::jak3 {
|
|
namespace method_17_collide_edge_work {
|
|
struct Cache {
|
|
void* format; // format
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
u32 call_addr = 0;
|
|
bool cop1_bc = false;
|
|
c->daddiu(sp, sp, -32); // daddiu sp, sp, -32
|
|
c->sd(ra, 0, sp); // sd ra, 0(sp)
|
|
c->sd(fp, 8, sp); // sd fp, 8(sp)
|
|
c->mov64(fp, t9); // or fp, t9, r0
|
|
c->sq(gp, 16, sp); // sq gp, 16(sp)
|
|
c->mov64(gp, a0); // or gp, a0, r0
|
|
c->lui(v1, 16180); // lui v1, 16180
|
|
c->ori(v1, v1, 65012); // ori v1, v1, 65012
|
|
c->mtc1(f0, v1); // mtc1 f0, v1
|
|
c->lwu(v1, 392, gp); // lwu v1, 392(gp)
|
|
// nop // sll r0, r0, 0
|
|
c->addiu(a0, r0, 896); // addiu a0, r0, 896
|
|
c->lwu(t3, 0, gp); // lwu t3, 0(gp)
|
|
c->addiu(a1, r0, 0); // addiu a1, r0, 0
|
|
c->daddiu(a2, gp, 6320); // daddiu a2, gp, 6320
|
|
c->addiu(a3, r0, 256); // addiu a3, r0, 256
|
|
c->lwu(t0, 0, t3); // lwu t0, 0(t3)
|
|
c->gprs[t1].du64[0] = 0; // or t1, r0, r0
|
|
c->lq(t2, 96, gp); // lq t2, 96(gp)
|
|
c->daddiu(t3, t3, 4908); // daddiu t3, t3, 4908
|
|
c->lq(t4, 112, gp); // lq t4, 112(gp)
|
|
|
|
block_1:
|
|
bc = c->sgpr64(t0) == 0; // beq t0, r0, L35
|
|
c->lwu(t5, 48, t3); // lwu t5, 48(t3)
|
|
if (bc) {goto block_14;} // branch non-likely
|
|
|
|
c->daddiu(t0, t0, -1); // daddiu t0, t0, -1
|
|
c->lqc2(vf1, 0, t3); // lqc2 vf1, 0(t3)
|
|
c->and_(t6, t5, a0); // and t6, t5, a0
|
|
c->lqc2(vf2, 16, t3); // lqc2 vf2, 16(t3)
|
|
bc = c->sgpr64(t6) == c->sgpr64(a1); // beq t6, a1, L34
|
|
c->lqc2(vf3, 32, t3); // lqc2 vf3, 32(t3)
|
|
if (bc) {goto block_5;} // branch non-likely
|
|
|
|
if (((s64)c->sgpr64(t6)) != ((s64)c->sgpr64(a3))) {// bnel t6, a3, L33
|
|
c->daddiu(t3, t3, 64); // daddiu t3, t3, 64
|
|
goto block_1;
|
|
}
|
|
|
|
block_5:
|
|
c->and_(t6, t5, v1); // and t6, t5, v1
|
|
c->vmini(DEST::xyzw, vf7, vf1, vf2); // vmini.xyzw vf7, vf1, vf2
|
|
bc = c->sgpr64(t6) != 0; // bne t6, r0, L33
|
|
c->vmax(DEST::xyzw, vf8, vf1, vf2); // vmax.xyzw vf8, vf1, vf2
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->vsub(DEST::xyz, vf4, vf2, vf1); // vsub.xyz vf4, vf2, vf1
|
|
// nop // sll r0, r0, 0
|
|
c->vsub(DEST::xyz, vf5, vf3, vf1); // vsub.xyz vf5, vf3, vf1
|
|
// nop // sll r0, r0, 0
|
|
c->vmini(DEST::xyzw, vf7, vf7, vf3); // vmini.xyzw vf7, vf7, vf3
|
|
// nop // sll r0, r0, 0
|
|
c->vmax(DEST::xyzw, vf8, vf8, vf3); // vmax.xyzw vf8, vf8, vf3
|
|
// nop // sll r0, r0, 0
|
|
c->vopmula(vf4, vf5); // vopmula.xyz acc, vf4, vf5
|
|
// nop // sll r0, r0, 0
|
|
c->vftoi0(DEST::xyzw, vf7, vf7); // vftoi0.xyzw vf7, vf7
|
|
// nop // sll r0, r0, 0
|
|
c->vftoi0(DEST::xyzw, vf8, vf8); // vftoi0.xyzw vf8, vf8
|
|
// nop // sll r0, r0, 0
|
|
c->vopmsub(vf6, vf5, vf4); // vopmsub.xyz vf6, vf5, vf4
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t7, vf7); // qmfc2.i t7, vf7
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t6, vf8); // qmfc2.i t6, vf8
|
|
// nop // sll r0, r0, 0
|
|
c->pcgtw(t7, t7, t4); // pcgtw t7, t7, t4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->vmul(DEST::xyzw, vf9, vf6, vf6); // vmul.xyzw vf9, vf6, vf6
|
|
// nop // sll r0, r0, 0
|
|
c->pcgtw(t6, t2, t6); // pcgtw t6, t2, t6
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->por(t6, t7, t6); // por t6, t7, t6
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->ppach(t6, r0, t6); // ppach t6, r0, t6
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->dsll(t6, t6, 16); // dsll t6, t6, 16
|
|
// nop // sll r0, r0, 0
|
|
if (((s64)c->sgpr64(t6)) != ((s64)0)) { // bnel t6, r0, L33
|
|
c->daddiu(t3, t3, 64); // daddiu t3, t3, 64
|
|
goto block_1;
|
|
}
|
|
|
|
// block_8:
|
|
c->vmula_bc(DEST::w, BC::x, vf0, vf9); // vmulax.w acc, vf0, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadda_bc(DEST::w, BC::y, vf0, vf9); // vmadday.w acc, vf0, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadd_bc(DEST::w, BC::z, vf9, vf0, vf9); // vmaddz.w vf9, vf0, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vrsqrt(vf0, BC::w, vf9, BC::w); // vrsqrt Q, vf0.w, vf9.w
|
|
// nop // sll r0, r0, 0
|
|
c->dsll32(t5, t5, 8); // dsll32 t5, t5, 8
|
|
c->dsrl32(t5, t5, 26); // dsrl32 t5, t5, 26
|
|
c->addiu(t6, r0, 2); // addiu t6, r0, 2
|
|
// nop // sll r0, r0, 0
|
|
c->vwaitq(); // vwaitq
|
|
// nop // sll r0, r0, 0
|
|
c->vmulq(DEST::xyz, vf6, vf6); // vmulq.xyz vf6, vf6, Q
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t7, vf6); // qmfc2.i t7, vf6
|
|
// nop // sll r0, r0, 0
|
|
c->dsra32(t7, t7, 0); // dsra32 t7, t7, 0
|
|
// nop // sll r0, r0, 0
|
|
c->mtc1(f1, t7); // mtc1 f1, t7
|
|
// nop // sll r0, r0, 0
|
|
cop1_bc = c->fprs[f1] < c->fprs[f0]; // c.lt.s f1, f0
|
|
c->addiu(t7, r0, 48); // addiu t7, r0, 48
|
|
if (cop1_bc) { // bc1tl L33
|
|
c->daddiu(t3, t3, 64); // daddiu t3, t3, 64
|
|
goto block_1;
|
|
}
|
|
|
|
// block_10:
|
|
if (((s64)c->sgpr64(t5)) == ((s64)c->sgpr64(t6))) {// beql t5, t6, L33
|
|
c->daddiu(t3, t3, 64); // daddiu t3, t3, 64
|
|
goto block_1;
|
|
}
|
|
|
|
// block_12:
|
|
bc = c->sgpr64(t1) == c->sgpr64(t7); // beq t1, t7, L36
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_15;} // branch non-likely
|
|
|
|
c->daddiu(t1, t1, 1); // daddiu t1, t1, 1
|
|
c->sw(t3, 0, a2); // sw t3, 0(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->sqc2(vf6, 16, a2); // sqc2 vf6, 16(a2)
|
|
c->daddiu(a2, a2, 32); // daddiu a2, a2, 32
|
|
// nop // sll r0, r0, 0
|
|
//beq r0, r0, L33 // beq r0, r0, L33
|
|
c->daddiu(t3, t3, 64); // daddiu t3, t3, 64
|
|
goto block_1; // branch always
|
|
|
|
|
|
block_14:
|
|
//beq r0, r0, L37 // beq r0, r0, L37
|
|
c->sw(t1, 16, gp); // sw t1, 16(gp)
|
|
goto block_16; // branch always
|
|
|
|
|
|
block_15:
|
|
c->load_symbol2(t9, cache.format); // lw t9, format(s7)
|
|
c->addiu(a0, r0, 0); // addiu a0, r0, 0
|
|
// daddiu a1, fp, L119 // daddiu a1, fp, L119
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
// c->jalr(call_addr); // jalr ra, t9
|
|
printf("ERROR: Exceeded max # of grabbable tris!\n");
|
|
c->addiu(v1, r0, 48); // addiu v1, r0, 48
|
|
c->sw(v1, 16, gp); // sw v1, 16(gp)
|
|
|
|
block_16:
|
|
c->gprs[v0].du64[0] = 0; // or v0, r0, r0
|
|
c->ld(ra, 0, sp); // ld ra, 0(sp)
|
|
c->ld(fp, 8, sp); // ld fp, 8(sp)
|
|
c->lq(gp, 16, sp); // lq gp, 16(sp)
|
|
//jr ra // jr ra
|
|
c->daddiu(sp, sp, 32); // daddiu sp, sp, 32
|
|
goto end_of_function; // return
|
|
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.format = intern_from_c(-1, 0, "format").c();
|
|
gLinkedFunctionTable.reg("(method 17 collide-edge-work)", execute, 512);
|
|
}
|
|
|
|
} // namespace method_17_collide_edge_work
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
// clang-format off
|
|
#include "game/mips2c/mips2c_private.h"
|
|
#include "game/kernel/jak3/kscheme.h"
|
|
using ::jak3::intern_from_c;
|
|
namespace Mips2C::jak3 {
|
|
namespace method_16_collide_edge_work {
|
|
struct Cache {
|
|
void* format; // format
|
|
} cache;
|
|
|
|
void sub_l20_b15(ExecutionContext* c) {
|
|
bool bc = false;
|
|
bool cop1_bc = false;
|
|
// block_15:
|
|
c->mov64(t4, t1); // or t4, t1, r0
|
|
c->lwu(t3, 12, a0); // lwu t3, 12(a0)
|
|
c->dsll32(t4, t4, 0); // dsll32 t4, t4, 0
|
|
c->gprs[t5].du64[0] = 0; // or t5, r0, r0
|
|
c->or_(t6, t4, t2); // or t6, t4, t2
|
|
c->daddiu(t4, a0, 1712); // daddiu t4, a0, 1712
|
|
|
|
block_16:
|
|
bc = c->sgpr64(t5) == c->sgpr64(t3); // beq t5, t3, L22
|
|
c->ld(t7, 8, t4); // ld t7, 8(t4)
|
|
if (bc) {goto block_20;} // branch non-likely
|
|
|
|
c->daddiu(t5, t5, 1); // daddiu t5, t5, 1
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
if (((s64)c->sgpr64(t6)) != ((s64)c->sgpr64(t7))) {// bnel t6, t7, L21
|
|
c->daddiu(t4, t4, 48); // daddiu t4, t4, 48
|
|
goto block_16;
|
|
}
|
|
|
|
// block_19:
|
|
//beq r0, r0, L24 // beq r0, r0, L24
|
|
c->sw(r0, 0, t4); // sw r0, 0(t4)
|
|
goto block_26; // branch always
|
|
|
|
|
|
block_20:
|
|
c->addiu(t5, r0, 96); // addiu t5, r0, 96
|
|
// nop // sll r0, r0, 0
|
|
if (((s64)c->sgpr64(t3)) == ((s64)c->sgpr64(t5))) {// beql t3, t5, L24
|
|
c->mov64(t4, s7); // or t4, s7, r0
|
|
goto block_26;
|
|
}
|
|
|
|
// block_22:
|
|
c->daddiu(t3, t3, 1); // daddiu t3, t3, 1
|
|
c->sw(s7, 0, t4); // sw s7, 0(t4)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(t1, 8, t4); // sw t1, 8(t4)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(t2, 12, t4); // sw t2, 12(t4)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(a1, 4, t4); // sw a1, 4(t4)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(t3, 12, a0); // sw t3, 12(a0)
|
|
c->vmove(DEST::xyzw, vf13, vf0); // vmove.xyzw vf13, vf0
|
|
c->lqc2(vf16, 0, t1); // lqc2 vf16, 0(t1)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf17, 0, t2); // lqc2 vf17, 0(t2)
|
|
c->vsub(DEST::xyzw, vf18, vf17, vf16); // vsub.xyzw vf18, vf17, vf16
|
|
// nop // sll r0, r0, 0
|
|
c->vsub(DEST::xyzw, vf19, vf1, vf16); // vsub.xyzw vf19, vf1, vf16
|
|
// nop // sll r0, r0, 0
|
|
c->vmul(DEST::xyzw, vf20, vf18, vf18); // vmul.xyzw vf20, vf18, vf18
|
|
// nop // sll r0, r0, 0
|
|
c->vsub_bc(DEST::x, BC::z, vf13, vf0, vf18); // vsubz.x vf13, vf0, vf18
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::y, vf20, vf20, vf20); // vaddy.x vf20, vf20, vf20
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::z, BC::x, vf13, vf0, vf18); // vaddx.z vf13, vf0, vf18
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::z, vf20, vf20, vf20); // vaddz.x vf20, vf20, vf20
|
|
// nop // sll r0, r0, 0
|
|
c->vmul(DEST::xyzw, vf15, vf13, vf19); // vmul.xyzw vf15, vf13, vf19
|
|
// nop // sll r0, r0, 0
|
|
c->vmul(DEST::xyzw, vf14, vf13, vf13); // vmul.xyzw vf14, vf13, vf13
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::z, vf15, vf15, vf15); // vaddz.x vf15, vf15, vf15
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::z, vf14, vf14, vf14); // vaddz.x vf14, vf14, vf14
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t2, vf15); // qmfc2.i t2, vf15
|
|
// nop // sll r0, r0, 0
|
|
c->vrsqrt(vf0, BC::w, vf14, BC::x); // vrsqrt Q, vf0.w, vf14.x
|
|
// nop // sll r0, r0, 0
|
|
c->mtc1(f3, t2); // mtc1 f3, t2
|
|
// nop // sll r0, r0, 0
|
|
cop1_bc = c->fprs[f4] < c->fprs[f2]; // c.lt.s f4, f2
|
|
// nop // sll r0, r0, 0
|
|
bc = cop1_bc; // bc1t L23
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_25;} // branch non-likely
|
|
|
|
cop1_bc = c->fprs[f3] < c->fprs[f4]; // c.lt.s f3, f4
|
|
// nop // sll r0, r0, 0
|
|
if (cop1_bc) { // bc1tl L24
|
|
c->sw(r0, 0, t4); // sw r0, 0(t4)
|
|
goto block_26;
|
|
}
|
|
|
|
block_25:
|
|
c->vwaitq(); // vwaitq
|
|
// nop // sll r0, r0, 0
|
|
c->vmulq(DEST::xyz, vf13, vf13); // vmulq.xyz vf13, vf13, Q
|
|
// nop // sll r0, r0, 0
|
|
// nop // vnop
|
|
// nop // sll r0, r0, 0
|
|
// nop // vnop
|
|
// nop // sll r0, r0, 0
|
|
c->vrsqrt(vf0, BC::w, vf20, BC::x); // vrsqrt Q, vf0.w, vf20.x
|
|
// nop // sll r0, r0, 0
|
|
c->vmul_bc(DEST::w, BC::w, vf18, vf0, vf0); // vmulw.w vf18, vf0, vf0
|
|
c->sqc2(vf13, 16, t4); // sqc2 vf13, 16(t4)
|
|
c->vwaitq(); // vwaitq
|
|
// nop // sll r0, r0, 0
|
|
c->vmulq(DEST::xyz, vf18, vf18); // vmulq.xyz vf18, vf18, Q
|
|
// nop // sll r0, r0, 0
|
|
// nop // vnop
|
|
// nop // sll r0, r0, 0
|
|
// nop // vnop
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sqc2(vf18, 32, t4); // sqc2 vf18, 32(t4)
|
|
|
|
block_26:
|
|
;
|
|
//jr ra // jr ra
|
|
// nop // sll r0, r0, 0
|
|
// goto end_of_function; // return
|
|
}
|
|
|
|
void sub_l25_b27(ExecutionContext* c) {
|
|
bool bc = false;
|
|
bool cop1_bc = false;
|
|
c->gprs[t2].du64[0] = 0; // or t2, r0, r0
|
|
c->lwu(t1, 8, a0); // lwu t1, 8(a0)
|
|
c->daddiu(t0, a0, 688); // daddiu t0, a0, 688
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_28:
|
|
bc = c->sgpr64(t2) == c->sgpr64(t1); // beq t2, t1, L27
|
|
c->lqc2(vf9, 0, t0); // lqc2 vf9, 0(t0)
|
|
if (bc) {goto block_37;} // branch non-likely
|
|
|
|
c->daddiu(t2, t2, 1); // daddiu t2, t2, 1
|
|
c->lqc2(vf10, 16, t0); // lqc2 vf10, 16(t0)
|
|
c->vsub(DEST::xyzw, vf9, vf9, vf8); // vsub.xyzw vf9, vf9, vf8
|
|
c->lqc2(vf11, 32, t0); // lqc2 vf11, 32(t0)
|
|
c->vsub(DEST::xyzw, vf10, vf10, vf8); // vsub.xyzw vf10, vf10, vf8
|
|
c->lqc2(vf12, 48, t0); // lqc2 vf12, 48(t0)
|
|
c->vsub(DEST::xyzw, vf11, vf11, vf8); // vsub.xyzw vf11, vf11, vf8
|
|
// nop // sll r0, r0, 0
|
|
c->vsub(DEST::xyzw, vf12, vf12, vf8); // vsub.xyzw vf12, vf12, vf8
|
|
// nop // sll r0, r0, 0
|
|
c->vmul(DEST::xyzw, vf9, vf9, vf9); // vmul.xyzw vf9, vf9, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmul(DEST::xyzw, vf10, vf10, vf10); // vmul.xyzw vf10, vf10, vf10
|
|
// nop // sll r0, r0, 0
|
|
c->vmul(DEST::xyzw, vf11, vf11, vf11); // vmul.xyzw vf11, vf11, vf11
|
|
// nop // sll r0, r0, 0
|
|
c->vmul(DEST::xyzw, vf12, vf12, vf12); // vmul.xyzw vf12, vf12, vf12
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::y, vf9, vf9, vf9); // vaddy.x vf9, vf9, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::y, vf10, vf10, vf10); // vaddy.x vf10, vf10, vf10
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::y, vf11, vf11, vf11); // vaddy.x vf11, vf11, vf11
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::y, vf12, vf12, vf12); // vaddy.x vf12, vf12, vf12
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::z, vf9, vf9, vf9); // vaddz.x vf9, vf9, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::z, vf10, vf10, vf10); // vaddz.x vf10, vf10, vf10
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::z, vf11, vf11, vf11); // vaddz.x vf11, vf11, vf11
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::x, BC::z, vf12, vf12, vf12); // vaddz.x vf12, vf12, vf12
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t3, vf9); // qmfc2.i t3, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->mtc1(f1, t3); // mtc1 f1, t3
|
|
// nop // sll r0, r0, 0
|
|
cop1_bc = c->fprs[f1] <= c->fprs[f0]; // c.le.s f1, f0
|
|
// nop // sll r0, r0, 0
|
|
bc = cop1_bc; // bc1t L28
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_40;} // branch non-likely
|
|
|
|
bc = c->sgpr64(t2) == c->sgpr64(t1); // beq t2, t1, L27
|
|
c->daddiu(t0, t0, 16); // daddiu t0, t0, 16
|
|
if (bc) {goto block_37;} // branch non-likely
|
|
|
|
c->mov128_gpr_vf(t3, vf10); // qmfc2.i t3, vf10
|
|
c->daddiu(t2, t2, 1); // daddiu t2, t2, 1
|
|
c->mtc1(f1, t3); // mtc1 f1, t3
|
|
// nop // sll r0, r0, 0
|
|
cop1_bc = c->fprs[f1] <= c->fprs[f0]; // c.le.s f1, f0
|
|
// nop // sll r0, r0, 0
|
|
bc = cop1_bc; // bc1t L28
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_40;} // branch non-likely
|
|
|
|
bc = c->sgpr64(t2) == c->sgpr64(t1); // beq t2, t1, L27
|
|
c->daddiu(t0, t0, 16); // daddiu t0, t0, 16
|
|
if (bc) {goto block_37;} // branch non-likely
|
|
|
|
c->mov128_gpr_vf(t3, vf11); // qmfc2.i t3, vf11
|
|
c->daddiu(t2, t2, 1); // daddiu t2, t2, 1
|
|
c->mtc1(f1, t3); // mtc1 f1, t3
|
|
// nop // sll r0, r0, 0
|
|
cop1_bc = c->fprs[f1] <= c->fprs[f0]; // c.le.s f1, f0
|
|
// nop // sll r0, r0, 0
|
|
bc = cop1_bc; // bc1t L28
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_40;} // branch non-likely
|
|
|
|
bc = c->sgpr64(t2) == c->sgpr64(t1); // beq t2, t1, L27
|
|
c->daddiu(t0, t0, 16); // daddiu t0, t0, 16
|
|
if (bc) {goto block_37;} // branch non-likely
|
|
|
|
c->mov128_gpr_vf(t3, vf12); // qmfc2.i t3, vf12
|
|
c->daddiu(t2, t2, 1); // daddiu t2, t2, 1
|
|
c->mtc1(f1, t3); // mtc1 f1, t3
|
|
// nop // sll r0, r0, 0
|
|
cop1_bc = c->fprs[f1] <= c->fprs[f0]; // c.le.s f1, f0
|
|
// nop // sll r0, r0, 0
|
|
bc = cop1_bc; // bc1t L28
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_40;} // branch non-likely
|
|
|
|
//beq r0, r0, L26 // beq r0, r0, L26
|
|
c->daddiu(t0, t0, 16); // daddiu t0, t0, 16
|
|
goto block_28; // branch always
|
|
|
|
|
|
block_37:
|
|
c->addiu(t2, r0, 64); // addiu t2, r0, 64
|
|
// nop // sll r0, r0, 0
|
|
if (((s64)c->sgpr64(t2)) == ((s64)c->sgpr64(t1))) {// beql t2, t1, L28
|
|
c->mov64(t0, s7); // or t0, s7, r0
|
|
goto block_40;
|
|
}
|
|
|
|
// block_39:
|
|
c->daddiu(t1, t1, 1); // daddiu t1, t1, 1
|
|
c->sqc2(vf8, 0, t0); // sqc2 vf8, 0(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(t1, 8, a0); // sw t1, 8(a0)
|
|
|
|
block_40:
|
|
;
|
|
//jr ra // jr ra
|
|
// nop // sll r0, r0, 0
|
|
// goto end_of_function; // return
|
|
}
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
u32 call_addr = 0;
|
|
// bool cop1_bc = false;
|
|
c->daddiu(sp, sp, -16); // daddiu sp, sp, -16
|
|
c->sd(ra, 0, sp); // sd ra, 0(sp)
|
|
c->sd(fp, 8, sp); // sd fp, 8(sp)
|
|
c->mov64(fp, t9); // or fp, t9, r0
|
|
c->lui(v1, 17617); // lui v1, 17617
|
|
c->ori(v1, v1, 46871); // ori v1, v1, 46871
|
|
c->mtc1(f0, v1); // mtc1 f0, v1
|
|
c->lwc1(f4, 404, a0); // lwc1 f4, 404(a0)
|
|
// nop // sll r0, r0, 0
|
|
c->mtc1(f2, r0); // mtc1 f2, r0
|
|
c->lwu(a1, 4, a0); // lwu a1, 4(a0)
|
|
// nop // sll r0, r0, 0
|
|
c->lwu(v1, 16, a0); // lwu v1, 16(a0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf1, 12, a1); // lqc2 vf1, 12(a1)
|
|
c->daddiu(a1, a0, 6320); // daddiu a1, a0, 6320
|
|
c->lqc2(vf6, 64, a0); // lqc2 vf6, 64(a0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf7, 80, a0); // lqc2 vf7, 80(a0)
|
|
c->vmove(DEST::xyzw, vf2, vf1); // vmove.xyzw vf2, vf1
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::y, BC::y, vf1, vf0, vf6); // vaddy.y vf1, vf0, vf6
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::y, BC::y, vf2, vf0, vf7); // vaddy.y vf2, vf0, vf7
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_1:
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L31
|
|
c->lwu(t0, 0, a1); // lwu t0, 0(a1)
|
|
if (bc) {goto block_43;} // branch non-likely
|
|
|
|
c->daddiu(v1, v1, -1); // daddiu v1, v1, -1
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf3, 0, t0); // lqc2 vf3, 0(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf4, 16, t0); // lqc2 vf4, 16(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf5, 32, t0); // lqc2 vf5, 32(t0)
|
|
// Unknown instr: bgezal r0, L25
|
|
c->vmove(DEST::xyzw, vf8, vf3); // vmove.xyzw vf8, vf3
|
|
// if (bc) {goto block_27;} // branch non-likely
|
|
sub_l25_b27(c);
|
|
|
|
bc = c->sgpr64(t0) == c->sgpr64(s7); // beq t0, s7, L29
|
|
c->mov64(a2, t0); // or a2, t0, r0
|
|
if (bc) {goto block_41;} // branch non-likely
|
|
|
|
// Unknown instr: bgezal r0, L25
|
|
c->vmove(DEST::xyzw, vf8, vf4); // vmove.xyzw vf8, vf4
|
|
// if (bc) {goto block_27;} // branch non-likely
|
|
sub_l25_b27(c);
|
|
|
|
bc = c->sgpr64(t0) == c->sgpr64(s7); // beq t0, s7, L29
|
|
c->mov64(a3, t0); // or a3, t0, r0
|
|
if (bc) {goto block_41;} // branch non-likely
|
|
|
|
// Unknown instr: bgezal r0, L25
|
|
c->vmove(DEST::xyzw, vf8, vf5); // vmove.xyzw vf8, vf5
|
|
// if (bc) {goto block_27;} // branch non-likely
|
|
sub_l25_b27(c);
|
|
|
|
bc = c->sgpr64(t0) == c->sgpr64(s7); // beq t0, s7, L29
|
|
c->mov64(t0, t0); // or t0, t0, r0
|
|
if (bc) {goto block_41;} // branch non-likely
|
|
|
|
c->mov64(t1, a2); // or t1, a2, r0
|
|
// nop // sll r0, r0, 0
|
|
// Unknown instr: bgezal r0, L20
|
|
c->mov64(t2, a3); // or t2, a3, r0
|
|
// if (bc) {goto block_15;} // branch non-likely
|
|
sub_l20_b15(c);
|
|
|
|
bc = c->sgpr64(t4) == c->sgpr64(s7); // beq t4, s7, L30
|
|
c->mov64(t1, a3); // or t1, a3, r0
|
|
if (bc) {goto block_42;} // branch non-likely
|
|
|
|
// Unknown instr: bgezal r0, L20
|
|
c->mov64(t2, t0); // or t2, t0, r0
|
|
// if (bc) {goto block_15;} // branch non-likely
|
|
sub_l20_b15(c);
|
|
|
|
bc = c->sgpr64(t4) == c->sgpr64(s7); // beq t4, s7, L30
|
|
c->mov64(t1, t0); // or t1, t0, r0
|
|
if (bc) {goto block_42;} // branch non-likely
|
|
|
|
// Unknown instr: bgezal r0, L20
|
|
c->mov64(t2, a2); // or t2, a2, r0
|
|
// if (bc) {goto block_15;} // branch non-likely
|
|
sub_l20_b15(c);
|
|
|
|
bc = c->sgpr64(t1) == c->sgpr64(s7); // beq t1, s7, L30
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_42;} // branch non-likely
|
|
|
|
//beq r0, r0, L19 // beq r0, r0, L19
|
|
c->daddiu(a1, a1, 32); // daddiu a1, a1, 32
|
|
goto block_1; // branch always
|
|
|
|
block_41:
|
|
c->load_symbol2(t9, cache.format); // lw t9, format(s7)
|
|
c->addiu(a0, r0, 0); // addiu a0, r0, 0
|
|
// daddiu a1, fp, L118 // daddiu a1, fp, L118
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
// c->jalr(call_addr); // jalr ra, t9
|
|
printf("ERROR: Too many edge verts found in edge grab!\n");
|
|
//beq r0, r0, L31 // beq r0, r0, L31
|
|
// nop // sll r0, r0, 0
|
|
goto block_43; // branch always
|
|
|
|
|
|
block_42:
|
|
c->load_symbol2(t9, cache.format); // lw t9, format(s7)
|
|
c->addiu(a0, r0, 0); // addiu a0, r0, 0
|
|
// daddiu a1, fp, L117 // daddiu a1, fp, L117
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
// c->jalr(call_addr); // jalr ra, t9
|
|
printf("ERROR: Too many edges found in edge grab!\n");
|
|
|
|
block_43:
|
|
c->gprs[v0].du64[0] = 0; // or v0, r0, r0
|
|
c->ld(ra, 0, sp); // ld ra, 0(sp)
|
|
c->ld(fp, 8, sp); // ld fp, 8(sp)
|
|
//jr ra // jr ra
|
|
c->daddiu(sp, sp, 16); // daddiu sp, sp, 16
|
|
goto end_of_function; // return
|
|
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.format = intern_from_c(-1, 0, "format").c();
|
|
gLinkedFunctionTable.reg("(method 16 collide-edge-work)", execute, 512);
|
|
}
|
|
|
|
} // namespace method_16_collide_edge_work
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
// clang-format off
|
|
#include "game/mips2c/mips2c_private.h"
|
|
#include "game/kernel/jak3/kscheme.h"
|
|
using ::jak3::intern_from_c;
|
|
namespace Mips2C::jak3 {
|
|
namespace method_18_collide_edge_work {
|
|
struct Cache {
|
|
void* vector_vector_distance; // vector-vector-distance
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
u32 call_addr = 0;
|
|
bool cop1_bc = false;
|
|
float acc;
|
|
c->daddiu(sp, sp, -96); // daddiu sp, sp, -96
|
|
c->sd(ra, 0, sp); // sd ra, 0(sp)
|
|
c->sq(s3, 16, sp); // sq s3, 16(sp)
|
|
c->sq(s4, 32, sp); // sq s4, 32(sp)
|
|
c->sq(s5, 48, sp); // sq s5, 48(sp)
|
|
c->sq(gp, 64, sp); // sq gp, 64(sp)
|
|
c->swc1(f30, 80, sp); // swc1 f30, 80(sp)
|
|
c->mov64(gp, a0); // or gp, a0, r0
|
|
c->mov64(s5, a1); // or s5, a1, r0
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf1, 16, s5); // lqc2 vf1, 16(s5)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(a0, 96, gp); // lq a0, 96(gp)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(a3, 112, gp); // lq a3, 112(gp)
|
|
c->vftoi0(DEST::xyzw, vf2, vf1); // vftoi0.xyzw vf2, vf1
|
|
c->lwu(v1, 4, gp); // lwu v1, 4(gp)
|
|
c->mov128_gpr_vf(a1, vf2); // qmfc2.i a1, vf2
|
|
c->lqc2(vf3, 16, a2); // lqc2 vf3, 16(a2)
|
|
c->pcgtw(a3, a1, a3); // pcgtw a3, a1, a3
|
|
c->lqc2(vf4, 368, gp); // lqc2 vf4, 368(gp)
|
|
c->pcgtw(a0, a0, a1); // pcgtw a0, a0, a1
|
|
c->lqc2(vf5, 12, v1); // lqc2 vf5, 12(v1)
|
|
c->por(v1, a3, a0); // por v1, a3, a0
|
|
c->lwc1(f0, 396, gp); // lwc1 f0, 396(gp)
|
|
c->ppach(v1, r0, v1); // ppach v1, r0, v1
|
|
c->lwc1(f1, 400, gp); // lwc1 f1, 400(gp)
|
|
c->dsll(v1, v1, 16); // dsll v1, v1, 16
|
|
bc = c->sgpr64(v1) != 0; // bne v1, r0, L10
|
|
c->lqc2(vf6, 144, gp); // lqc2 vf6, 144(gp)
|
|
if (bc) {goto block_24;} // branch non-likely
|
|
|
|
c->vmul_bc(DEST::xyzw, BC::x, vf10, vf3, vf4); // vmulx.xyzw vf10, vf3, vf4
|
|
c->lqc2(vf11, 128, gp); // lqc2 vf11, 128(gp)
|
|
c->vadd(DEST::xyzw, vf10, vf10, vf1); // vadd.xyzw vf10, vf10, vf1
|
|
c->vsub(DEST::xyzw, vf7, vf5, vf10); // vsub.xyzw vf7, vf5, vf10
|
|
c->vmul(DEST::xyzw, vf7, vf7, vf7); // vmul.xyzw vf7, vf7, vf7
|
|
c->vadd_bc(DEST::x, BC::z, vf7, vf7, vf7); // vaddz.x vf7, vf7, vf7
|
|
c->mov128_gpr_vf(v1, vf7); // qmfc2.i v1, vf7
|
|
c->mtc1(f2, v1); // mtc1 f2, v1
|
|
cop1_bc = c->fprs[f0] < c->fprs[f2]; // c.lt.s f0, f2
|
|
bc = cop1_bc; // bc1t L10
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_24;} // branch non-likely
|
|
|
|
c->vsub(DEST::xyzw, vf8, vf1, vf5); // vsub.xyzw vf8, vf1, vf5
|
|
c->vmul(DEST::xyzw, vf7, vf8, vf8); // vmul.xyzw vf7, vf8, vf8
|
|
c->vadd_bc(DEST::x, BC::z, vf7, vf7, vf7); // vaddz.x vf7, vf7, vf7
|
|
c->vrsqrt(vf0, BC::w, vf7, BC::x); // vrsqrt Q, vf0.w, vf7.x
|
|
// nop // sll r0, r0, 0
|
|
c->vwaitq(); // vwaitq
|
|
// nop // sll r0, r0, 0
|
|
c->vmulq(DEST::xz, vf8, vf8); // vmulq.xz vf8, vf8, Q
|
|
c->vmul(DEST::xyzw, vf9, vf8, vf6); // vmul.xyzw vf9, vf8, vf6
|
|
c->vadd_bc(DEST::x, BC::z, vf9, vf9, vf9); // vaddz.x vf9, vf9, vf9
|
|
c->mov128_gpr_vf(v1, vf9); // qmfc2.i v1, vf9
|
|
c->mtc1(f3, v1); // mtc1 f3, v1
|
|
cop1_bc = c->fprs[f3] < c->fprs[f1]; // c.lt.s f3, f1
|
|
bc = cop1_bc; // bc1t L10
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_24;} // branch non-likely
|
|
|
|
c->vsub(DEST::xyzw, vf7, vf11, vf1); // vsub.xyzw vf7, vf11, vf1
|
|
c->sqc2(vf1, 16, s5); // sqc2 vf1, 16(s5)
|
|
c->vmul(DEST::xyzw, vf7, vf7, vf7); // vmul.xyzw vf7, vf7, vf7
|
|
c->sb(r0, 8, s5); // sb r0, 8(s5)
|
|
c->sqc2(vf10, 32, s5); // sqc2 vf10, 32(s5)
|
|
c->vadd_bc(DEST::x, BC::z, vf7, vf7, vf7); // vaddz.x vf7, vf7, vf7
|
|
c->sw(a2, 12, s5); // sw a2, 12(s5)
|
|
c->mov128_gpr_vf(v1, vf7); // qmfc2.i v1, vf7
|
|
c->sw(v1, 4, s5); // sw v1, 4(s5)
|
|
c->ld(v1, 384, gp); // ld v1, 384(gp)
|
|
c->andi(v1, v1, 2); // andi v1, v1, 2
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L8
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_20;} // branch non-likely
|
|
|
|
c->lwu(s3, 12, s5); // lwu s3, 12(s5)
|
|
c->lwu(s4, 408, gp); // lwu s4, 408(gp)
|
|
c->lui(v1, 16256); // lui v1, 16256
|
|
c->mtc1(f30, v1); // mtc1 f30, v1
|
|
c->load_symbol2(t9, cache.vector_vector_distance);// lw t9, vector-vector-distance(s7)
|
|
c->lwu(v1, 8, s3); // lwu v1, 8(s3)
|
|
c->daddu(a0, r0, v1); // daddu a0, r0, v1
|
|
c->daddu(a1, r0, s4); // daddu a1, r0, s4
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mtc1(f0, v0); // mtc1 f0, v0
|
|
cop1_bc = c->fprs[f0] < c->fprs[f30]; // c.lt.s f0, f30
|
|
bc = cop1_bc; // bc1t L4
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, 4
|
|
if (bc) {goto block_6;} // branch non-likely
|
|
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
|
|
block_6:
|
|
if (((s64)c->sgpr64(s7)) != ((s64)c->sgpr64(v1))) {// bnel s7, v1, L7
|
|
c->mov64(v1, v1); // or v1, v1, r0
|
|
goto block_18;
|
|
}
|
|
|
|
// block_8:
|
|
c->load_symbol2(t9, cache.vector_vector_distance);// lw t9, vector-vector-distance(s7)
|
|
c->lwu(v1, 12, s3); // lwu v1, 12(s3)
|
|
c->daddu(a0, r0, v1); // daddu a0, r0, v1
|
|
c->daddu(a1, r0, s4); // daddu a1, r0, s4
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mtc1(f0, v0); // mtc1 f0, v0
|
|
cop1_bc = c->fprs[f0] < c->fprs[f30]; // c.lt.s f0, f30
|
|
bc = cop1_bc; // bc1t L5
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, 4
|
|
if (bc) {goto block_10;} // branch non-likely
|
|
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
|
|
block_10:
|
|
if (((s64)c->sgpr64(s7)) != ((s64)c->sgpr64(v1))) {// bnel s7, v1, L7
|
|
c->mov64(v1, v1); // or v1, v1, r0
|
|
goto block_18;
|
|
}
|
|
|
|
// block_12:
|
|
c->load_symbol2(t9, cache.vector_vector_distance);// lw t9, vector-vector-distance(s7)
|
|
c->lwu(v1, 8, s3); // lwu v1, 8(s3)
|
|
c->daddu(a0, r0, v1); // daddu a0, r0, v1
|
|
c->daddiu(a1, s4, 16); // daddiu a1, s4, 16
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mtc1(f0, v0); // mtc1 f0, v0
|
|
cop1_bc = c->fprs[f0] < c->fprs[f30]; // c.lt.s f0, f30
|
|
bc = cop1_bc; // bc1t L6
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, 4
|
|
if (bc) {goto block_14;} // branch non-likely
|
|
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
|
|
block_14:
|
|
if (((s64)c->sgpr64(s7)) != ((s64)c->sgpr64(v1))) {// bnel s7, v1, L7
|
|
c->mov64(v1, v1); // or v1, v1, r0
|
|
goto block_18;
|
|
}
|
|
|
|
// block_16:
|
|
c->load_symbol2(t9, cache.vector_vector_distance);// lw t9, vector-vector-distance(s7)
|
|
c->lwu(v1, 12, s3); // lwu v1, 12(s3)
|
|
c->daddu(a0, r0, v1); // daddu a0, r0, v1
|
|
c->daddiu(a1, s4, 16); // daddiu a1, s4, 16
|
|
call_addr = c->gprs[t9].du32[0]; // function call:
|
|
c->sll(v0, ra, 0); // sll v0, ra, 0
|
|
c->jalr(call_addr); // jalr ra, t9
|
|
c->mtc1(f0, v0); // mtc1 f0, v0
|
|
cop1_bc = c->fprs[f0] < c->fprs[f30]; // c.lt.s f0, f30
|
|
bc = cop1_bc; // bc1t L7
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, 4
|
|
if (bc) {goto block_18;} // branch non-likely
|
|
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
|
|
block_18:
|
|
bc = c->sgpr64(s7) != c->sgpr64(v1); // bne s7, v1, L8
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_20;} // branch non-likely
|
|
|
|
//beq r0, r0, L10 // beq r0, r0, L10
|
|
// nop // sll r0, r0, 0
|
|
goto block_24; // branch always
|
|
|
|
|
|
block_20:
|
|
c->ld(v1, 384, gp); // ld v1, 384(gp)
|
|
c->andi(v1, v1, 4); // andi v1, v1, 4
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L9
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_23;} // branch non-likely
|
|
|
|
c->lwu(v1, 12, s5); // lwu v1, 12(s5)
|
|
c->daddiu(a0, v1, 16); // daddiu a0, v1, 16
|
|
c->daddiu(v1, gp, 144); // daddiu v1, gp, 144
|
|
c->lwc1(f0, 0, a0); // lwc1 f0, 0(a0)
|
|
c->lwc1(f1, 4, a0); // lwc1 f1, 4(a0)
|
|
c->lwc1(f2, 8, a0); // lwc1 f2, 8(a0)
|
|
c->lwc1(f3, 0, v1); // lwc1 f3, 0(v1)
|
|
c->lwc1(f4, 4, v1); // lwc1 f4, 4(v1)
|
|
c->lwc1(f5, 8, v1); // lwc1 f5, 8(v1)
|
|
// Unknown instr: mula.s f0, f3
|
|
acc = c->fprs[f0] * c->fprs[f3];
|
|
// Unknown instr: madda.s f1, f4
|
|
acc += c->fprs[f1] * c->fprs[f4];
|
|
// Unknown instr: madd.s f0, f2, f5
|
|
c->fprs[f0] = acc + c->fprs[f2] * c->fprs[f5];
|
|
c->mfc1(v1, f0); // mfc1 v1, f0
|
|
c->mtc1(f0, v1); // mtc1 f0, v1
|
|
c->abss(f0, f0); // abs.s f0, f0
|
|
c->lui(v1, 16179); // lui v1, 16179
|
|
c->ori(v1, v1, 13107); // ori v1, v1, 13107
|
|
c->mtc1(f1, v1); // mtc1 f1, v1
|
|
cop1_bc = c->fprs[f1] < c->fprs[f0]; // c.lt.s f1, f0
|
|
bc = !cop1_bc; // bc1f L9
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_23;} // branch non-likely
|
|
|
|
//beq r0, r0, L10 // beq r0, r0, L10
|
|
// nop // sll r0, r0, 0
|
|
goto block_24; // branch always
|
|
|
|
|
|
block_23:
|
|
c->daddiu(v1, s7, 4); // daddiu v1, s7, #t
|
|
c->mov64(v0, v1); // or v0, v1, r0
|
|
//beq r0, r0, L11 // beq r0, r0, L11
|
|
// nop // sll r0, r0, 0
|
|
goto block_26; // branch always
|
|
|
|
|
|
block_24:
|
|
c->mov64(v0, s7); // or v0, s7, r0
|
|
//beq r0, r0, L11 // beq r0, r0, L11
|
|
// nop // sll r0, r0, 0
|
|
goto block_26; // branch always
|
|
|
|
c->gprs[v0].du64[0] = 0; // or v0, r0, r0
|
|
|
|
block_26:
|
|
c->ld(ra, 0, sp); // ld ra, 0(sp)
|
|
c->lwc1(f30, 80, sp); // lwc1 f30, 80(sp)
|
|
c->lq(gp, 64, sp); // lq gp, 64(sp)
|
|
c->lq(s5, 48, sp); // lq s5, 48(sp)
|
|
c->lq(s4, 32, sp); // lq s4, 32(sp)
|
|
c->lq(s3, 16, sp); // lq s3, 16(sp)
|
|
//jr ra // jr ra
|
|
c->daddiu(sp, sp, 96); // daddiu sp, sp, 96
|
|
goto end_of_function; // return
|
|
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.vector_vector_distance = intern_from_c(-1, 0, "vector-vector-distance").c();
|
|
gLinkedFunctionTable.reg("(method 18 collide-edge-work)", execute, 256);
|
|
}
|
|
|
|
} // namespace method_18_collide_edge_work
|
|
} // namespace Mips2C
|