mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 11:26:18 -04:00
2595 lines
145 KiB
C++
2595 lines
145 KiB
C++
//--------------------------MIPS2C---------------------
|
|
#include "game/kernel/jak1/kscheme.h"
|
|
#include "game/mips2c/mips2c_private.h"
|
|
using namespace jak1;
|
|
namespace Mips2C::jak1 {
|
|
// clang-format off
|
|
namespace {
|
|
void exec_0(ExecutionContext* c) {
|
|
// nop | sub.xyzw vf05, vf03, vf02 0
|
|
c->vfs[vf05].vf.sub(Mask::xyzw, c->vf_src(vf03).vf, c->vf_src(vf02).vf);
|
|
// nop | sub.xyzw vf06, vf04, vf02 1
|
|
c->vfs[vf06].vf.sub(Mask::xyzw, c->vf_src(vf04).vf, c->vf_src(vf02).vf);
|
|
// nop | sub.xyzw vf10, vf08, vf07 2
|
|
c->vfs[vf10].vf.sub(Mask::xyzw, c->vf_src(vf08).vf, c->vf_src(vf07).vf);
|
|
// nop | sub.xyzw vf11, vf09, vf07 3
|
|
c->vfs[vf11].vf.sub(Mask::xyzw, c->vf_src(vf09).vf, c->vf_src(vf07).vf);
|
|
// nop | sub.xyzw vf15, vf13, vf12 4
|
|
c->vfs[vf15].vf.sub(Mask::xyzw, c->vf_src(vf13).vf, c->vf_src(vf12).vf);
|
|
// nop | sub.xyzw vf16, vf14, vf12 5
|
|
c->vfs[vf16].vf.sub(Mask::xyzw, c->vf_src(vf14).vf, c->vf_src(vf12).vf);
|
|
// nop | sub.xyzw vf20, vf18, vf17 6
|
|
c->vfs[vf20].vf.sub(Mask::xyzw, c->vf_src(vf18).vf, c->vf_src(vf17).vf);
|
|
// nop | sub.xyzw vf21, vf19, vf17 7
|
|
c->vfs[vf21].vf.sub(Mask::xyzw, c->vf_src(vf19).vf, c->vf_src(vf17).vf);
|
|
// nop | opmula.xyz ACC, vf05, vf06 8
|
|
c->vopmula(vf05, vf06); // ASSERT(false);
|
|
// nop | opmsub.xyz vf05, vf06, vf05 9
|
|
c->vopmsub(vf05, vf06, vf05); //ASSERT(false);
|
|
// nop | opmula.xyz ACC, vf10, vf11 10
|
|
c->vopmula(vf10, vf11); // ASSERT(false);
|
|
// nop | opmsub.xyz vf10, vf11, vf10 11
|
|
c->vopmsub(vf10, vf11, vf10); // ASSERT(false);
|
|
// nop | opmula.xyz ACC, vf15, vf16 12
|
|
c->vopmula(vf15, vf16); // ASSERT(false);
|
|
// nop | opmsub.xyz vf15, vf16, vf15 13
|
|
c->vopmsub(vf15, vf16, vf15); // ASSERT(false);
|
|
// nop | opmula.xyz ACC, vf20, vf21 14
|
|
c->vopmula(vf20, vf21); // ASSERT(false);
|
|
// nop | opmsub.xyz vf20, vf21, vf20 15
|
|
c->vopmsub(vf20, vf21, vf20); // ASSERT(false);
|
|
// nop | mul.xyz vf05, vf05, vf01 16
|
|
c->vfs[vf05].vf.mul(Mask::xyz, c->vf_src(vf05).vf, c->vf_src(vf01).vf);
|
|
// nop | mul.xyz vf10, vf10, vf01 17
|
|
c->vfs[vf10].vf.mul(Mask::xyz, c->vf_src(vf10).vf, c->vf_src(vf01).vf);
|
|
// nop | mul.xyz vf15, vf15, vf01 18
|
|
c->vfs[vf15].vf.mul(Mask::xyz, c->vf_src(vf15).vf, c->vf_src(vf01).vf);
|
|
// nop | mul.xyz vf20, vf20, vf01 19
|
|
c->vfs[vf20].vf.mul(Mask::xyz, c->vf_src(vf20).vf, c->vf_src(vf01).vf);
|
|
// nop | addx.y vf05, vf05, vf05 20
|
|
c->vfs[vf05].vf.add(Mask::y, c->vf_src(vf05).vf, c->vf_src(vf05).vf.x());
|
|
// nop | addx.y vf10, vf10, vf10 21
|
|
c->vfs[vf10].vf.add(Mask::y, c->vf_src(vf10).vf, c->vf_src(vf10).vf.x());
|
|
// nop | addx.y vf15, vf15, vf15 22
|
|
c->vfs[vf15].vf.add(Mask::y, c->vf_src(vf15).vf, c->vf_src(vf15).vf.x());
|
|
// nop | addx.y vf20, vf20, vf20 23
|
|
c->vfs[vf20].vf.add(Mask::y, c->vf_src(vf20).vf, c->vf_src(vf20).vf.x());
|
|
// nop | addz.y vf22, vf05, vf05 24
|
|
c->vfs[vf22].vf.add(Mask::y, c->vf_src(vf05).vf, c->vf_src(vf05).vf.z());
|
|
// nop | addz.y vf23, vf10, vf10 25
|
|
c->vfs[vf23].vf.add(Mask::y, c->vf_src(vf10).vf, c->vf_src(vf10).vf.z());
|
|
// nop | addz.y vf24, vf15, vf15 :e 26
|
|
c->vfs[vf24].vf.add(Mask::y, c->vf_src(vf15).vf, c->vf_src(vf15).vf.z());
|
|
// nop | addz.y vf25, vf20, vf20 27
|
|
c->vfs[vf25].vf.add(Mask::y, c->vf_src(vf20).vf, c->vf_src(vf20).vf.z());
|
|
}
|
|
|
|
void exec_28(ExecutionContext* c) {
|
|
// nop | mul.xyzw vf27, vf20, Q 28
|
|
c->vfs[vf27].vf.mul(Mask::xyzw, c->vf_src(vf20).vf, c->Q);
|
|
// div Q, vf13.x, vf17.x | sub.xyzw vf19, vf01, vf03 29
|
|
c->vfs[vf19].vf.sub(Mask::xyzw, c->vf_src(vf01).vf, c->vf_src(vf03).vf); c->Q = c->vfs[vf13].vf.x() / c->vfs[vf17].vf.x();
|
|
// move.xyzw vf23, vf07 | sub.xyzw vf20, vf01, vf04 30
|
|
c->vfs[vf20].vf.sub(Mask::xyzw, c->vf_src(vf01).vf, c->vf_src(vf04).vf); c->vfs[vf23].vf.move(Mask::xyzw, c->vf_src(vf07).vf);
|
|
// nop | sub.xyzw vf21, vf01, vf05 31
|
|
c->vfs[vf21].vf.sub(Mask::xyzw, c->vf_src(vf01).vf, c->vf_src(vf05).vf);
|
|
// move.xyzw vf25, vf09 | sub.xyzw vf22, vf01, vf06 32
|
|
c->vfs[vf22].vf.sub(Mask::xyzw, c->vf_src(vf01).vf, c->vf_src(vf06).vf); c->vfs[vf25].vf.move(Mask::xyzw, c->vf_src(vf09).vf);
|
|
// move.xyzw vf26, vf10 | sub.xyzw vf24, vf08, vf27 33
|
|
c->vfs[vf24].vf.sub(Mask::xyzw, c->vf_src(vf08).vf, c->vf_src(vf27).vf); c->vfs[vf26].vf.move(Mask::xyzw, c->vf_src(vf10).vf);
|
|
// nop | mul.xyzw vf11, vf03, vf02 34
|
|
c->vfs[vf11].vf.mul(Mask::xyzw, c->vf_src(vf03).vf, c->vf_src(vf02).vf);
|
|
// nop | mul.xyz vf15, vf19, vf02 35
|
|
c->vfs[vf15].vf.mul(Mask::xyz, c->vf_src(vf19).vf, c->vf_src(vf02).vf);
|
|
// div Q, vf14.x, vf18.x | mul.xyzw vf12, vf04, vf02 36
|
|
float oldQ = c->Q;
|
|
c->vfs[vf12].vf.mul(Mask::xyzw, c->vf_src(vf04).vf, c->vf_src(vf02).vf); c->Q = c->vfs[vf14].vf.x() / c->vfs[vf18].vf.x();
|
|
// move.xyzw vf07, vf03 | mul.xyzw vf28, vf28, Q 37
|
|
c->vfs[vf28].vf.mul(Mask::xyzw, c->vf_src(vf28).vf, oldQ); c->vfs[vf07].vf.move(Mask::xyzw, c->vf_src(vf03).vf);
|
|
// move.xyzw vf08, vf04 | mul.xyz vf16, vf20, vf02 38
|
|
c->vfs[vf16].vf.mul(Mask::xyz, c->vf_src(vf20).vf, c->vf_src(vf02).vf); c->vfs[vf08].vf.move(Mask::xyzw, c->vf_src(vf04).vf);
|
|
// move.xyzw vf09, vf05 | addy.x vf11, vf11, vf11 39
|
|
c->vfs[vf11].vf.add(Mask::x, c->vf_src(vf11).vf, c->vf_src(vf11).vf.y()); c->vfs[vf09].vf.move(Mask::xyzw, c->vf_src(vf05).vf);
|
|
// move.xyzw vf10, vf06 | addy.x vf15, vf15, vf15 40
|
|
c->vfs[vf15].vf.add(Mask::x, c->vf_src(vf15).vf, c->vf_src(vf15).vf.y()); c->vfs[vf10].vf.move(Mask::xyzw, c->vf_src(vf06).vf);
|
|
// nop | sub.xyzw vf25, vf25, vf28 41
|
|
c->vfs[vf25].vf.sub(Mask::xyzw, c->vf_src(vf25).vf, c->vf_src(vf28).vf);
|
|
// nop | addy.x vf12, vf12, vf12 42
|
|
c->vfs[vf12].vf.add(Mask::x, c->vf_src(vf12).vf, c->vf_src(vf12).vf.y());
|
|
// nop | mul.xyzw vf29, vf29, Q 43
|
|
c->vfs[vf29].vf.mul(Mask::xyzw, c->vf_src(vf29).vf, c->Q);
|
|
// nop | addy.x vf16, vf16, vf16 44
|
|
c->vfs[vf16].vf.add(Mask::x, c->vf_src(vf16).vf, c->vf_src(vf16).vf.y());
|
|
// nop | addz.x vf11, vf11, vf11 45
|
|
c->vfs[vf11].vf.add(Mask::x, c->vf_src(vf11).vf, c->vf_src(vf11).vf.z());
|
|
// nop | addz.x vf15, vf15, vf15 46
|
|
c->vfs[vf15].vf.add(Mask::x, c->vf_src(vf15).vf, c->vf_src(vf15).vf.z());
|
|
// nop | sub.xyzw vf26, vf26, vf29 47
|
|
c->vfs[vf26].vf.sub(Mask::xyzw, c->vf_src(vf26).vf, c->vf_src(vf29).vf);
|
|
// nop | addz.x vf12, vf12, vf12 48
|
|
c->vfs[vf12].vf.add(Mask::x, c->vf_src(vf12).vf, c->vf_src(vf12).vf.z());
|
|
// nop | addz.x vf16, vf16, vf16 49
|
|
c->vfs[vf16].vf.add(Mask::x, c->vf_src(vf16).vf, c->vf_src(vf16).vf.z());
|
|
// nop | addw.x vf11, vf11, vf11 50
|
|
c->vfs[vf11].vf.add(Mask::x, c->vf_src(vf11).vf, c->vf_src(vf11).vf.w());
|
|
// nop | mul.xyzw vf13, vf09, vf02 51
|
|
|
|
c->vfs[vf13].vf.mul(Mask::xyzw, c->vf_src(vf09).vf, c->vf_src(vf02).vf);
|
|
c->vfs[vf13].vf.saturate_infs();
|
|
|
|
// nop | addw.x vf12, vf12, vf12 52
|
|
c->vfs[vf12].vf.add(Mask::x, c->vf_src(vf12).vf, c->vf_src(vf12).vf.w());
|
|
// nop | mul.xyz vf17, vf21, vf02 53
|
|
c->vfs[vf17].vf.mul(Mask::xyz, c->vf_src(vf21).vf, c->vf_src(vf02).vf);
|
|
// nop | mul.xyzw vf14, vf10, vf02 54
|
|
c->vfs[vf14].vf.mul(Mask::xyzw, c->vf_src(vf10).vf, c->vf_src(vf02).vf);
|
|
c->vfs[vf14].vf.saturate_infs();
|
|
|
|
// div Q, vf11.x, vf15.x | mul.xyz vf18, vf22, vf02 55
|
|
c->vfs[vf18].vf.mul(Mask::xyz, c->vf_src(vf22).vf, c->vf_src(vf02).vf); c->Q = c->vfs[vf11].vf.x() / c->vfs[vf15].vf.x();
|
|
// nop | addy.x vf13, vf13, vf13 56
|
|
c->vfs[vf13].vf.add(Mask::x, c->vf_src(vf13).vf, c->vf_src(vf13).vf.y());
|
|
|
|
// nop | addy.x vf17, vf17, vf17 57
|
|
c->vfs[vf17].vf.add(Mask::x, c->vf_src(vf17).vf, c->vf_src(vf17).vf.y());
|
|
// nop | addy.x vf14, vf14, vf14 58
|
|
c->vfs[vf14].vf.add(Mask::x, c->vf_src(vf14).vf, c->vf_src(vf14).vf.y());
|
|
|
|
// nop | addy.x vf18, vf18, vf18 59
|
|
c->vfs[vf18].vf.add(Mask::x, c->vf_src(vf18).vf, c->vf_src(vf18).vf.y());
|
|
// nop | addz.x vf13, vf13, vf13 60
|
|
c->vfs[vf13].vf.add(Mask::x, c->vf_src(vf13).vf, c->vf_src(vf13).vf.z());
|
|
|
|
// nop | addz.x vf17, vf17, vf17 61
|
|
c->vfs[vf17].vf.add(Mask::x, c->vf_src(vf17).vf, c->vf_src(vf17).vf.z());
|
|
// div Q, vf12.x, vf16.x | addz.x vf14, vf14, vf14 62
|
|
oldQ = c->Q;
|
|
c->vfs[vf14].vf.add(Mask::x, c->vf_src(vf14).vf, c->vf_src(vf14).vf.z()); c->Q = c->vfs[vf12].vf.x() / c->vfs[vf16].vf.x();
|
|
|
|
// nop | mul.xyzw vf19, vf19, Q 63
|
|
c->vfs[vf19].vf.mul(Mask::xyzw, c->vf_src(vf19).vf, oldQ);
|
|
// move.xyzw vf28, vf21 | addz.x vf18, vf18, vf18 64
|
|
c->vfs[vf18].vf.add(Mask::x, c->vf_src(vf18).vf, c->vf_src(vf18).vf.z()); c->vfs[vf28].vf.move(Mask::xyzw, c->vf_src(vf21).vf);
|
|
// move.xyzw vf29, vf22 | addw.x vf13, vf13, vf13 65
|
|
c->vfs[vf13].vf.add(Mask::x, c->vf_src(vf13).vf, c->vf_src(vf13).vf.w()); c->vfs[vf29].vf.move(Mask::xyzw, c->vf_src(vf22).vf);
|
|
c->vfs[vf13].vf.saturate_infs();
|
|
|
|
// nop | addw.x vf14, vf14, vf14 :e 66
|
|
c->vfs[vf14].vf.add(Mask::x, c->vf_src(vf14).vf, c->vf_src(vf14).vf.w());
|
|
c->vfs[vf14].vf.saturate_infs();
|
|
|
|
// nop | sub.xyzw vf07, vf07, vf19 67
|
|
c->vfs[vf07].vf.sub(Mask::xyzw, c->vf_src(vf07).vf, c->vf_src(vf19).vf);
|
|
}
|
|
|
|
void exec_68(ExecutionContext* c) {
|
|
// nop | mul.xyzw vf27, vf20, Q 68
|
|
c->vfs[vf27].vf.mul(Mask::xyzw, c->vf_src(vf20).vf, c->Q);
|
|
// div Q, vf13.x, vf17.x | nop 69
|
|
c->Q = c->vfs[vf13].vf.x() / c->vfs[vf17].vf.x();
|
|
// move.xyzw vf23, vf07 | nop 70
|
|
c->vfs[vf23].vf.move(Mask::xyzw, c->vf_src(vf07).vf);
|
|
// nop | nop 71
|
|
|
|
// move.xyzw vf25, vf09 | nop 72
|
|
c->vfs[vf25].vf.move(Mask::xyzw, c->vf_src(vf09).vf);
|
|
// move.xyzw vf26, vf10 | sub.xyzw vf24, vf08, vf27 73
|
|
c->vfs[vf24].vf.sub(Mask::xyzw, c->vf_src(vf08).vf, c->vf_src(vf27).vf); c->vfs[vf26].vf.move(Mask::xyzw, c->vf_src(vf10).vf);
|
|
// nop | nop 74
|
|
|
|
// nop | nop 75
|
|
|
|
// div Q, vf14.x, vf18.x | nop 76
|
|
float oldQ = c->Q;
|
|
c->Q = c->vfs[vf14].vf.x() / c->vfs[vf18].vf.x();
|
|
// nop | mul.xyzw vf28, vf28, Q 77
|
|
c->vfs[vf28].vf.mul(Mask::xyzw, c->vf_src(vf28).vf, oldQ);
|
|
// nop | nop 78
|
|
|
|
// nop | nop 79
|
|
|
|
// nop | nop 80
|
|
|
|
// nop | sub.xyzw vf25, vf25, vf28 81
|
|
c->vfs[vf25].vf.sub(Mask::xyzw, c->vf_src(vf25).vf, c->vf_src(vf28).vf); // was bad
|
|
// nop | nop 82
|
|
|
|
// nop | mul.xyzw vf29, vf29, Q 83
|
|
c->vfs[vf29].vf.mul(Mask::xyzw, c->vf_src(vf29).vf, c->Q);
|
|
// nop | nop 84
|
|
|
|
// nop | nop 85
|
|
|
|
// nop | nop :e 86
|
|
|
|
// nop | sub.xyzw vf26, vf26, vf29 87
|
|
c->vfs[vf26].vf.sub(Mask::xyzw, c->vf_src(vf26).vf, c->vf_src(vf29).vf);
|
|
|
|
}
|
|
} // namespace
|
|
|
|
namespace shadow_xform_verts {
|
|
struct Cache {
|
|
void* fake_scratchpad_data; // *fake-scratchpad-data*
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
// nop // sll r0, r0, 0
|
|
c->lw(v1, 0, a0); // lw v1, 0(a0)
|
|
// nop // sll r0, r0, 0
|
|
c->lw(a2, 20, a0); // lw a2, 20(a0)
|
|
c->dsll(v1, v1, 4); // dsll v1, v1, 4
|
|
c->lw(t0, 24, a0); // lw t0, 24(a0)
|
|
c->daddu(a2, a2, a0); // daddu a2, a2, a0
|
|
c->lh(a3, 8, a0); // lh a3, 8(a0)
|
|
c->daddu(t0, t0, a0); // daddu t0, t0, a0
|
|
c->lw(t1, 4, a0); // lw t1, 4(a0)
|
|
c->daddu(v1, a0, v1); // daddu v1, a0, v1
|
|
c->sw(a2, 0, a1); // sw a2, 0(a1)
|
|
c->daddiu(v1, v1, 144); // daddiu v1, v1, 144
|
|
// nop // sll r0, r0, 0
|
|
c->mov64(a1, t0); // or a1, t0, r0
|
|
c->lh(t0, 10, a0); // lh t0, 10(a0)
|
|
c->mov64(a2, a2); // or a2, a2, r0
|
|
// nop // sll r0, r0, 0
|
|
c->dsubu(a3, a3, t0); // dsubu a3, a3, t0
|
|
get_fake_spad_addr(t0, cache.fake_scratchpad_data, 0, c);// lui t0, 28672
|
|
c->ori(t0, t0, 2608); // ori t0, t0, 2608
|
|
bc = c->sgpr64(a3) == 0; // beq a3, r0, L100
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
|
|
block_1:
|
|
c->daddiu(a3, a3, -1); // daddiu a3, a3, -1
|
|
c->lbu(t0, 0, a1); // lbu t0, 0(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t1, 1, a1); // lbu t1, 1(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->daddiu(a1, a1, 2); // daddiu a1, a1, 2
|
|
c->dsll(t0, t0, 7); // dsll t0, t0, 7
|
|
// nop // sll r0, r0, 0
|
|
c->daddu(t0, t0, v1); // daddu t0, t0, v1
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf1, 0, t0); // lqc2 vf1, 0(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf2, 16, t0); // lqc2 vf2, 16(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf3, 32, t0); // lqc2 vf3, 32(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf4, 48, t0); // lqc2 vf4, 48(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf9, 0, a2); // lqc2 vf9, 0(a2)
|
|
c->vmula_bc(DEST::xyzw, BC::w, vf4, vf0); // vmulaw.xyzw acc, vf4, vf0
|
|
// nop // sll r0, r0, 0
|
|
c->vmadda_bc(DEST::xyzw, BC::x, vf1, vf9); // vmaddax.xyzw acc, vf1, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadda_bc(DEST::xyzw, BC::y, vf2, vf9); // vmadday.xyzw acc, vf2, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadd_bc(DEST::xyz, BC::z, vf9, vf3, vf9); // vmaddz.xyz vf9, vf3, vf9
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sqc2(vf9, 0, a2); // sqc2 vf9, 0(a2)
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
// nop // sll r0, r0, 0
|
|
bc = c->sgpr64(a3) != 0; // bne a3, r0, L99
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
|
|
block_2:
|
|
// nop // sll r0, r0, 0
|
|
c->lh(a0, 10, a0); // lh a0, 10(a0)
|
|
bc = c->sgpr64(a0) == 0; // beq a0, r0, L102
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_5;} // branch non-likely
|
|
|
|
|
|
block_3:
|
|
c->daddiu(a0, a0, -1); // daddiu a0, a0, -1
|
|
c->lbu(t0, 0, a1); // lbu t0, 0(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(a3, 1, a1); // lbu a3, 1(a1)
|
|
c->dsll(t0, t0, 7); // dsll t0, t0, 7
|
|
c->daddiu(a1, a1, 2); // daddiu a1, a1, 2
|
|
c->dsll(a3, a3, 7); // dsll a3, a3, 7
|
|
c->daddu(t0, t0, v1); // daddu t0, t0, v1
|
|
c->daddu(a3, a3, v1); // daddu a3, a3, v1
|
|
c->lqc2(vf1, 0, t0); // lqc2 vf1, 0(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf2, 16, t0); // lqc2 vf2, 16(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf3, 32, t0); // lqc2 vf3, 32(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf4, 48, t0); // lqc2 vf4, 48(t0)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf9, 0, a2); // lqc2 vf9, 0(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf5, 0, a3); // lqc2 vf5, 0(a3)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf6, 16, a3); // lqc2 vf6, 16(a3)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf7, 32, a3); // lqc2 vf7, 32(a3)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf8, 48, a3); // lqc2 vf8, 48(a3)
|
|
c->vsub_bc(DEST::w, BC::w, vf10, vf0, vf9); // vsubw.w vf10, vf0, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmula_bc(DEST::xyzw, BC::w, vf4, vf0); // vmulaw.xyzw acc, vf4, vf0
|
|
// nop // sll r0, r0, 0
|
|
c->vmadda_bc(DEST::xyzw, BC::x, vf1, vf9); // vmaddax.xyzw acc, vf1, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadda_bc(DEST::xyzw, BC::y, vf2, vf9); // vmadday.xyzw acc, vf2, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadd_bc(DEST::xyz, BC::z, vf10, vf3, vf9); // vmaddz.xyz vf10, vf3, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmula_bc(DEST::xyzw, BC::w, vf8, vf0); // vmulaw.xyzw acc, vf8, vf0
|
|
// nop // sll r0, r0, 0
|
|
c->vmadda_bc(DEST::xyzw, BC::x, vf5, vf9); // vmaddax.xyzw acc, vf5, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadda_bc(DEST::xyzw, BC::y, vf6, vf9); // vmadday.xyzw acc, vf6, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadd_bc(DEST::xyz, BC::z, vf9, vf7, vf9); // vmaddz.xyz vf9, vf7, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmula_bc(DEST::xyz, BC::w, vf10, vf9); // vmulaw.xyz acc, vf10, vf9
|
|
// nop // sll r0, r0, 0
|
|
c->vmadd_bc(DEST::xyz, BC::w, vf9, vf9, vf10); // vmaddw.xyz vf9, vf9, vf10
|
|
// nop // sll r0, r0, 0
|
|
c->vadd_bc(DEST::w, BC::x, vf9, vf0, vf0); // vaddx.w vf9, vf0, vf0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sqc2(vf9, 0, a2); // sqc2 vf9, 0(a2)
|
|
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
// nop // sll r0, r0, 0
|
|
bc = c->sgpr64(a0) != 0; // bne a0, r0, L101
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_3;} // branch non-likely
|
|
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_5:
|
|
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
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
|
|
gLinkedFunctionTable.reg("shadow-xform-verts", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_xform_verts
|
|
} // namespace Mips2C
|
|
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_calc_dual_verts {
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
// nop // sll r0, r0, 0
|
|
c->lw(v1, 16, a1); // lw v1, 16(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lw(a2, 0, a1); // lw a2, 0(a1)
|
|
c->daddiu(v1, v1, 15); // daddiu v1, v1, 15
|
|
c->lqc2(vf1, 64, a1); // lqc2 vf1, 64(a1)
|
|
c->dsra(v1, v1, 4); // dsra v1, v1, 4
|
|
c->lqc2(vf2, 80, a1); // lqc2 vf2, 80(a1)
|
|
c->dsll(a3, v1, 4); // dsll a3, v1, 4
|
|
c->lh(a0, 8, a0); // lh a0, 8(a0)
|
|
c->mov64(v1, a3); // or v1, a3, r0
|
|
c->sw(a3, 44, a1); // sw a3, 44(a1)
|
|
c->mov64(a2, a2); // or a2, a2, r0
|
|
// nop // sll r0, r0, 0
|
|
bc = c->sgpr64(a0) == 0; // beq a0, r0, L97
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_9;} // branch non-likely
|
|
|
|
// nop // sll r0, r0, 0
|
|
c->lq(a3, 0, a2); // lq a3, 0(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t0, 16, a2); // lq t0, 16(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t1, 32, a2); // lq t1, 32(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t2, 48, a2); // lq t2, 48(a2)
|
|
c->daddiu(a2, a2, 64); // daddiu a2, a2, 64
|
|
c->mov128_vf_gpr(vf3, a3); // qmtc2.i vf3, a3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf4, t0); // qmtc2.ni vf4, t0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf5, t1); // qmtc2.ni vf5, t1
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf6, t2); // qmtc2.ni vf6, t2
|
|
exec_28(c);// Unknown instr: vcallms 28
|
|
|
|
// nop // sll r0, r0, 0
|
|
c->daddiu(a0, a0, -4); // daddiu a0, a0, -4
|
|
c->lq(a3, 0, a2); // lq a3, 0(a2)
|
|
bc = ((s64)c->sgpr64(a0)) <= 0; // blez a0, L95
|
|
c->lq(t0, 16, a2); // lq t0, 16(a2)
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t1, 32, a2); // lq t1, 32(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t2, 48, a2); // lq t2, 48(a2)
|
|
c->daddiu(a2, a2, 64); // daddiu a2, a2, 64
|
|
c->mov128_vf_gpr(vf3, a3); // qmtc2.i vf3, a3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf4, t0); // qmtc2.ni vf4, t0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf5, t1); // qmtc2.ni vf5, t1
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf6, t2); // qmtc2.ni vf6, t2
|
|
|
|
block_3:
|
|
exec_28(c);// Unknown instr: vcallms 28
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(a3, vf23); // qmfc2.i a3, vf23 // 39
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sq(a3, 0, v1); // sq a3, 0(v1) // 47
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(a3, vf24); // qmfc2.ni a3, vf24 // 51
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sq(a3, 16, v1); // sq a3, 16(v1) // 59
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(a3, vf25); // qmfc2.ni a3, vf25 // 67
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sq(a3, 32, v1); // sq a3, 32(v1) // 75
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(a3, vf26); // qmfc2.ni a3, vf26 // 83
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sq(a3, 48, v1); // sq a3, 48(v1) // 91
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lq(a3, 0, a2); // lq a3, 0(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t0, 16, a2); // lq t0, 16(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t1, 32, a2); // lq t1, 32(a2)
|
|
c->daddiu(a0, a0, -4); // daddiu a0, a0, -4
|
|
c->lq(t2, 48, a2); // lq t2, 48(a2)
|
|
c->daddiu(a2, a2, 64); // daddiu a2, a2, 64
|
|
c->daddiu(v1, v1, 64); // daddiu v1, v1, 64
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf3, a3); // qmtc2.ni vf3, a3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf4, t0); // qmtc2.ni vf4, t0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf5, t1); // qmtc2.ni vf5, t1
|
|
bc = ((s64)c->sgpr64(a0)) > 0; // bgtz a0, L94
|
|
c->mov128_vf_gpr(vf6, t2); // qmtc2.ni vf6, t2
|
|
if (bc) {goto block_3;} // branch non-likely
|
|
|
|
block_4:
|
|
exec_68(c);// Unknown instr: vcallms 68
|
|
// nop // sll r0, r0, 0
|
|
// nop // vnop
|
|
// nop // sll r0, r0, 0
|
|
c->daddiu(a2, a0, 3); // daddiu a2, a0, 3
|
|
c->mov128_gpr_vf(a3, vf23); // qmfc2.i a3, vf23
|
|
c->daddiu(t0, a0, 2); // daddiu t0, a0, 2
|
|
c->mov128_gpr_vf(t1, vf24); // qmfc2.i t1, vf24
|
|
c->daddiu(t2, a0, 1); // daddiu t2, a0, 1
|
|
c->mov128_gpr_vf(t3, vf25); // qmfc2.i t3, vf25
|
|
c->daddiu(a0, a0, 4); // daddiu a0, a0, 4
|
|
c->mov128_gpr_vf(t4, vf26); // qmfc2.i t4, vf26
|
|
bc = c->sgpr64(a2) == 0; // beq a2, r0, L96
|
|
c->sq(a3, 0, v1); // sq a3, 0(v1)
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
|
|
bc = c->sgpr64(t0) == 0; // beq t0, r0, L96
|
|
c->sq(t1, 16, v1); // sq t1, 16(v1)
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
|
|
bc = c->sgpr64(t2) == 0; // beq t2, r0, L96
|
|
c->sq(t3, 32, v1); // sq t3, 32(v1)
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
|
|
// nop // sll r0, r0, 0
|
|
c->sq(t4, 48, v1); // sq t4, 48(v1)
|
|
|
|
block_8:
|
|
c->dsll(a0, a0, 4); // dsll a0, a0, 4
|
|
// nop // sll r0, r0, 0
|
|
c->daddu(v1, v1, a0); // daddu v1, v1, a0
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_9:
|
|
c->sw(v1, 16, a1); // sw v1, 16(a1)
|
|
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
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
gLinkedFunctionTable.reg("shadow-calc-dual-verts", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_calc_dual_verts
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_scissor_edges {
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
// nop // sll r0, r0, 0
|
|
c->lw(a3, 44, a1); // lw a3, 44(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lw(a2, 0, a1); // lw a2, 0(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf3, 112, a1); // lqc2 vf3, 112(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lh(v1, 8, a0); // lh v1, 8(a0)
|
|
c->mov64(a0, a3); // or a0, a3, r0
|
|
// nop // sll r0, r0, 0
|
|
c->mov64(a1, a2); // or a1, a2, r0
|
|
// nop // sll r0, r0, 0
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L92
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
|
|
|
|
block_1:
|
|
c->lqc2(vf1, 0, a1); // lqc2 vf1, 0(a1)
|
|
c->lqc2(vf2, 0, a0); // lqc2 vf2, 0(a0)
|
|
c->vadd_bc(DEST::z, BC::w, vf7, vf1, vf3); // vaddw.z vf7, vf1, vf3
|
|
c->vadd_bc(DEST::z, BC::w, vf8, vf2, vf3); // vaddw.z vf8, vf2, vf3
|
|
c->vsub_bc(DEST::z, BC::z, vf6, vf1, vf2); // vsubz.z vf6, vf1, vf2
|
|
c->vadd_bc(DEST::z, BC::w, vf5, vf1, vf3); // vaddw.z vf5, vf1, vf3
|
|
c->vadd_bc(DEST::y, BC::z, vf7, vf0, vf7); // vaddz.y vf7, vf0, vf7
|
|
c->vadd_bc(DEST::y, BC::z, vf8, vf0, vf8); // vaddz.y vf8, vf0, vf8
|
|
c->vsub(DEST::xyz, vf4, vf2, vf1); // vsub.xyz vf4, vf2, vf1
|
|
c->mov128_gpr_vf(a2, vf7); // qmfc2.i a2, vf7
|
|
c->mov128_gpr_vf(a3, vf8); // qmfc2.i a3, vf8
|
|
bc = ((s64)c->sgpr64(a2)) < 0; // bltz a2, L89
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
bc = ((s64)c->sgpr64(a3)) > 0; // bgtz a3, L91
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
//beq r0, r0, L90 // beq r0, r0, L90
|
|
// nop // sll r0, r0, 0
|
|
goto block_6; // branch always
|
|
|
|
|
|
block_4:
|
|
bc = ((s64)c->sgpr64(a3)) < 0; // bltz a3, L91
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
c->vdiv(vf5, BC::z, vf6, BC::z); // vdiv Q, vf5.z, vf6.z
|
|
c->vwaitq(); // vwaitq
|
|
c->vmulq(DEST::xyzw, vf4, vf4); // vmulq.xyzw vf4, vf4, Q
|
|
// nop // vnop
|
|
// nop // vnop
|
|
// nop // vnop
|
|
c->vadd(DEST::xyzw, vf1, vf1, vf4); // vadd.xyzw vf1, vf1, vf4
|
|
//beq r0, r0, L91 // beq r0, r0, L91
|
|
c->sqc2(vf1, 0, a1); // sqc2 vf1, 0(a1)
|
|
goto block_7; // branch always
|
|
|
|
|
|
block_6:
|
|
c->vdiv(vf5, BC::z, vf6, BC::z); // vdiv Q, vf5.z, vf6.z
|
|
c->vwaitq(); // vwaitq
|
|
c->vmulq(DEST::xyzw, vf4, vf4); // vmulq.xyzw vf4, vf4, Q
|
|
// nop // vnop
|
|
// nop // vnop
|
|
// nop // vnop
|
|
c->vadd(DEST::xyzw, vf1, vf1, vf4); // vadd.xyzw vf1, vf1, vf4
|
|
//beq r0, r0, L91 // beq r0, r0, L91
|
|
c->sqc2(vf1, 0, a0); // sqc2 vf1, 0(a0) was bad
|
|
goto block_7; // branch always
|
|
|
|
|
|
block_7:
|
|
c->daddiu(a1, a1, 16); // daddiu a1, a1, 16
|
|
c->daddiu(a0, a0, 16); // daddiu a0, a0, 16
|
|
c->daddiu(v1, v1, -1); // daddiu v1, v1, -1
|
|
bc = c->sgpr64(v1) != 0; // bne v1, r0, L88
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
|
|
block_8:
|
|
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("shadow-scissor-edges", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_scissor_edges
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_scissor_top {
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
// nop // sll r0, r0, 0
|
|
c->lw(a2, 44, a1); // lw a2, 44(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lw(v1, 0, a1); // lw v1, 0(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lqc2(vf3, 96, a1); // lqc2 vf3, 96(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->lh(a0, 8, a0); // lh a0, 8(a0)
|
|
c->mov64(a1, a2); // or a1, a2, r0
|
|
// nop // sll r0, r0, 0
|
|
c->mov64(v1, v1); // or v1, v1, r0
|
|
// nop // sll r0, r0, 0
|
|
bc = c->sgpr64(a0) == 0; // beq a0, r0, L86
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
|
|
block_1:
|
|
c->lqc2(vf1, 0, v1); // lqc2 vf1, 0(v1)
|
|
c->lqc2(vf2, 0, a1); // lqc2 vf2, 0(a1)
|
|
c->vsub(DEST::xyzw, vf4, vf2, vf1); // vsub.xyzw vf4, vf2, vf1
|
|
c->vmul(DEST::xyzw, vf5, vf1, vf3); // vmul.xyzw vf5, vf1, vf3
|
|
c->vmul(DEST::xyz, vf6, vf4, vf3); // vmul.xyz vf6, vf4, vf3
|
|
c->vadd_bc(DEST::y, BC::x, vf5, vf5, vf5); // vaddx.y vf5, vf5, vf5
|
|
c->vadd_bc(DEST::x, BC::y, vf6, vf6, vf6); // vaddy.x vf6, vf6, vf6
|
|
c->vadd_bc(DEST::y, BC::z, vf5, vf5, vf5); // vaddz.y vf5, vf5, vf5
|
|
c->vadd_bc(DEST::x, BC::z, vf6, vf6, vf6); // vaddz.x vf6, vf6, vf6
|
|
c->vadd_bc(DEST::y, BC::w, vf5, vf5, vf5); // vaddw.y vf5, vf5, vf5
|
|
c->mov128_gpr_vf(a2, vf5); // qmfc2.i a2, vf5
|
|
// nop // sll r0, r0, 0
|
|
bc = ((s64)c->sgpr64(a2)) < 0; // bltz a2, L85
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_3;} // branch non-likely
|
|
|
|
c->vdiv(vf5, BC::y, vf6, BC::x); // vdiv Q, vf5.y, vf6.x
|
|
c->vwaitq(); // vwaitq
|
|
c->vmulq(DEST::xyzw, vf4, vf4); // vmulq.xyzw vf4, vf4, Q
|
|
c->vsub(DEST::xyzw, vf1, vf1, vf4); // vsub.xyzw vf1, vf1, vf4
|
|
c->sqc2(vf1, 0, v1); // sqc2 vf1, 0(v1)
|
|
|
|
block_3:
|
|
c->daddiu(v1, v1, 16); // daddiu v1, v1, 16
|
|
c->daddiu(a1, a1, 16); // daddiu a1, a1, 16
|
|
c->daddiu(a0, a0, -1); // daddiu a0, a0, -1
|
|
bc = c->sgpr64(a0) != 0; // bne a0, r0, L84
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
|
|
block_4:
|
|
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("shadow-scissor-top", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_scissor_top
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_init_vars {
|
|
struct Cache {
|
|
void* math_camera; // *math-camera*
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
c->load_symbol(v1, cache.math_camera); // lw v1, *math-camera*(s7)
|
|
c->mov64(v1, v1); // or v1, v1, r0
|
|
c->lqc2(vf7, 364, v1); // lqc2 vf7, 364(v1)
|
|
c->lqc2(vf8, 380, v1); // lqc2 vf8, 380(v1)
|
|
c->lqc2(vf9, 396, v1); // lqc2 vf9, 396(v1)
|
|
c->lqc2(vf10, 412, v1); // lqc2 vf10, 412(v1)
|
|
c->lqc2(vf1, 128, a1); // lqc2 vf1, 128(a1)
|
|
c->lqc2(vf11, 80, a1); // lqc2 vf11, 80(a1)
|
|
c->lqc2(vf12, 96, a1); // lqc2 vf12, 96(a1)
|
|
c->lqc2(vf2, 64, a1); // lqc2 vf2, 64(a1)
|
|
c->vmula_bc(DEST::xyzw, BC::x, vf7, vf1); // vmulax.xyzw acc, vf7, vf1
|
|
c->vmadda_bc(DEST::xyzw, BC::y, vf8, vf1); // vmadday.xyzw acc, vf8, vf1
|
|
c->vmadd_bc(DEST::xyzw, BC::z, vf1, vf9, vf1); // vmaddz.xyzw vf1, vf9, vf1
|
|
c->vmula_bc(DEST::xyzw, BC::x, vf7, vf11); // vmulax.xyzw acc, vf7, vf11
|
|
c->vmadda_bc(DEST::xyzw, BC::y, vf8, vf11); // vmadday.xyzw acc, vf8, vf11
|
|
c->vmadd_bc(DEST::xyz, BC::z, vf11, vf9, vf11); // vmaddz.xyz vf11, vf9, vf11
|
|
c->vmula_bc(DEST::xyzw, BC::x, vf7, vf12); // vmulax.xyzw acc, vf7, vf12
|
|
c->vmadda_bc(DEST::xyzw, BC::y, vf8, vf12); // vmadday.xyzw acc, vf8, vf12
|
|
c->vmadd_bc(DEST::xyz, BC::z, vf12, vf9, vf12); // vmaddz.xyz vf12, vf9, vf12
|
|
c->vmul(DEST::xyzw, vf13, vf10, vf11); // vmul.xyzw vf13, vf10, vf11
|
|
c->vmula_bc(DEST::xyzw, BC::w, vf10, vf0); // vmulaw.xyzw acc, vf10, vf0
|
|
c->vmadda_bc(DEST::xyzw, BC::x, vf7, vf2); // vmaddax.xyzw acc, vf7, vf2
|
|
c->vmul(DEST::xyzw, vf14, vf10, vf12); // vmul.xyzw vf14, vf10, vf12
|
|
c->vsub_bc(DEST::w, BC::x, vf13, vf13, vf13); // vsubx.w vf13, vf13, vf13
|
|
c->vsub_bc(DEST::w, BC::x, vf14, vf14, vf14); // vsubx.w vf14, vf14, vf14
|
|
c->vmadda_bc(DEST::xyzw, BC::y, vf8, vf2); // vmadday.xyzw acc, vf8, vf2
|
|
c->vmadd_bc(DEST::xyzw, BC::z, vf2, vf9, vf2); // vmaddz.xyzw vf2, vf9, vf2
|
|
c->vsub_bc(DEST::w, BC::y, vf13, vf13, vf13); // vsuby.w vf13, vf13, vf13
|
|
c->vsub_bc(DEST::w, BC::y, vf14, vf14, vf14); // vsuby.w vf14, vf14, vf14
|
|
c->vsub_bc(DEST::w, BC::z, vf11, vf13, vf13); // vsubz.w vf11, vf13, vf13
|
|
c->vsub_bc(DEST::w, BC::z, vf12, vf14, vf14); // vsubz.w vf12, vf14, vf14
|
|
c->sqc2(vf2, 64, a1); // sqc2 vf2, 64(a1)
|
|
c->sqc2(vf1, 128, a1); // sqc2 vf1, 128(a1)
|
|
c->sqc2(vf11, 80, a1); // sqc2 vf11, 80(a1)
|
|
c->sqc2(vf12, 96, a1); // sqc2 vf12, 96(a1)
|
|
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
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.math_camera = intern_from_c("*math-camera*").c();
|
|
gLinkedFunctionTable.reg("shadow-init-vars", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_init_vars
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_find_facing_single_tris {
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->daddiu(sp, sp, -64); // daddiu sp, sp, -64
|
|
c->sd(ra, 0, sp); // sd ra, 0(sp)
|
|
c->sq(s4, 16, sp); // sq s4, 16(sp)
|
|
c->sq(s5, 32, sp); // sq s5, 32(sp)
|
|
c->sq(gp, 48, sp); // sq gp, 48(sp)
|
|
c->lw(v1, 16, a1); // lw v1, 16(a1)
|
|
c->lh(t0, 12, a0); // lh t0, 12(a0)
|
|
c->mov64(a2, v1); // or a2, v1, r0
|
|
c->lw(a3, 28, a0); // lw a3, 28(a0)
|
|
c->daddu(a0, a3, a0); // daddu a0, a3, a0
|
|
c->mov64(a3, a0); // or a3, a0, r0
|
|
c->lqc2(vf2, 64, a1); // lqc2 vf2, 64(a1)
|
|
c->lqc2(vf1, 128, a1); // lqc2 vf1, 128(a1)
|
|
c->lqc2(vf11, 80, a1); // lqc2 vf11, 80(a1)
|
|
c->lw(a0, 0, a1); // lw a0, 0(a1)
|
|
c->pextlw(a0, a0, a0); // pextlw a0, a0, a0
|
|
c->pextlw(a0, a0, a0); // pextlw a0, a0, a0
|
|
c->daddiu(t0, t0, -4); // daddiu t0, t0, -4
|
|
c->addiu(t1, r0, 1); // addiu t1, r0, 1
|
|
bc = ((s64)c->sgpr64(t0)) < 0; // bltz t0, L78
|
|
c->daddiu(t0, t0, 4); // daddiu t0, t0, 4
|
|
if (bc) {goto block_11;} // branch non-likely
|
|
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t3, 0, a3); // lq t3, 0(a3)
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->pextub(t2, r0, t3); // pextub t2, r0, t3
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlb(t3, r0, t3); // pextlb t3, r0, t3
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->psllh(t2, t2, 4); // psllh t2, t2, 4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->psllh(t4, t3, 4); // psllh t4, t3, 4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextuh(t3, r0, t4); // pextuh t3, r0, t4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlh(t4, r0, t4); // pextlh t4, r0, t4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextuh(t7, r0, t2); // pextuh t7, r0, t2
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlh(t5, r0, t2); // pextlh t5, r0, t2
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->paddw(t6, t4, a0); // paddw t6, t4, a0
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pcpyud(t4, t6, r0); // pcpyud t4, t6, r0
|
|
c->lq(t2, 0, t6); // lq t2, 0(t6)
|
|
c->paddw(t8, t3, a0); // paddw t8, t3, a0
|
|
c->lq(t3, 0, t4); // lq t3, 0(t4)
|
|
c->pcpyud(t9, t8, r0); // pcpyud t9, t8, r0
|
|
c->lq(t4, 0, t8); // lq t4, 0(t8)
|
|
c->dsra32(t6, t6, 0); // dsra32 t6, t6, 0
|
|
c->dsra32(t8, t8, 0); // dsra32 t8, t8, 0
|
|
c->paddw(s5, t5, a0); // paddw s5, t5, a0
|
|
c->lq(t5, 0, t9); // lq t5, 0(t9)
|
|
c->pcpyud(t9, s5, r0); // pcpyud t9, s5, r0
|
|
c->lq(t6, 0, t6); // lq t6, 0(t6)
|
|
c->paddw(gp, t7, a0); // paddw gp, t7, a0
|
|
c->lq(t7, 0, t8); // lq t7, 0(t8)
|
|
c->pcpyud(ra, gp, r0); // pcpyud ra, gp, r0
|
|
c->lq(t8, 0, s5); // lq t8, 0(s5)
|
|
c->dsra32(s5, s5, 0); // dsra32 s5, s5, 0
|
|
c->dsra32(s4, gp, 0); // dsra32 s4, gp, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lq(s5, 0, s5); // lq s5, 0(s5)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t9, 0, t9); // lq t9, 0(t9)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(gp, 0, gp); // lq gp, 0(gp)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(s4, 0, s4); // lq s4, 0(s4)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(ra, 0, ra); // lq ra, 0(ra)
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf2, t2); // qmtc2.ni vf2, t2
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf3, t6); // qmtc2.ni vf3, t6
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf4, t3); // qmtc2.ni vf4, t3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf7, t4); // qmtc2.ni vf7, t4
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf8, t7); // qmtc2.ni vf8, t7
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf9, t5); // qmtc2.ni vf9, t5
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf12, t8); // qmtc2.ni vf12, t8
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf13, s5); // qmtc2.ni vf13, s5
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf14, t9); // qmtc2.ni vf14, t9
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf17, gp); // qmtc2.ni vf17, gp
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf18, s4); // qmtc2.ni vf18, s4
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf19, ra); // qmtc2.ni vf19, ra
|
|
|
|
block_2:
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t3, 16, a3); // lq t3, 16(a3)
|
|
c->daddiu(t0, t0, -4); // daddiu t0, t0, -4
|
|
exec_0(c);// Unknown instr: vcallms 0
|
|
c->pextub(t2, r0, t3); // pextub t2, r0, t3
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlb(t3, r0, t3); // pextlb t3, r0, t3
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->psllh(t2, t2, 4); // psllh t2, t2, 4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->psllh(t4, t3, 4); // psllh t4, t3, 4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextuh(t3, r0, t4); // pextuh t3, r0, t4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlh(t4, r0, t4); // pextlh t4, r0, t4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextuh(t7, r0, t2); // pextuh t7, r0, t2
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlh(t5, r0, t2); // pextlh t5, r0, t2
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->paddw(t6, t4, a0); // paddw t6, t4, a0
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pcpyud(t4, t6, r0); // pcpyud t4, t6, r0
|
|
c->lq(t2, 0, t6); // lq t2, 0(t6)
|
|
c->paddw(t8, t3, a0); // paddw t8, t3, a0
|
|
c->lq(t3, 0, t4); // lq t3, 0(t4)
|
|
c->pcpyud(t9, t8, r0); // pcpyud t9, t8, r0
|
|
c->lq(t4, 0, t8); // lq t4, 0(t8)
|
|
c->dsra32(t6, t6, 0); // dsra32 t6, t6, 0
|
|
c->dsra32(t8, t8, 0); // dsra32 t8, t8, 0
|
|
c->paddw(s5, t5, a0); // paddw s5, t5, a0
|
|
c->lq(t5, 0, t9); // lq t5, 0(t9)
|
|
c->pcpyud(t9, s5, r0); // pcpyud t9, s5, r0
|
|
c->lq(t6, 0, t6); // lq t6, 0(t6)
|
|
c->paddw(gp, t7, a0); // paddw gp, t7, a0
|
|
c->lq(t7, 0, t8); // lq t7, 0(t8)
|
|
c->pcpyud(ra, gp, r0); // pcpyud ra, gp, r0
|
|
c->lq(t8, 0, s5); // lq t8, 0(s5)
|
|
c->dsra32(s5, s5, 0); // dsra32 s5, s5, 0
|
|
c->dsra32(s4, gp, 0); // dsra32 s4, gp, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lq(s5, 0, s5); // lq s5, 0(s5)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t9, 0, t9); // lq t9, 0(t9)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(gp, 0, gp); // lq gp, 0(gp)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(s4, 0, s4); // lq s4, 0(s4)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(ra, 0, ra); // lq ra, 0(ra)
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf2, t2); // qmtc2.ni vf2, t2
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf3, t6); // qmtc2.ni vf3, t6
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf4, t3); // qmtc2.ni vf4, t3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf7, t4); // qmtc2.ni vf7, t4
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf8, t7); // qmtc2.ni vf8, t7
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf9, t5); // qmtc2.ni vf9, t5
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf12, t8); // qmtc2.ni vf12, t8
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf13, s5); // qmtc2.ni vf13, s5
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf14, t9); // qmtc2.ni vf14, t9
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf17, gp); // qmtc2.ni vf17, gp
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf18, s4); // qmtc2.ni vf18, s4
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf19, ra); // qmtc2.ni vf19, ra
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t3, vf22); // qmfc2.ni t3, vf22
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t4, vf23); // qmfc2.ni t4, vf23
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t2, vf24); // qmfc2.ni t2, vf24
|
|
bc = ((s64)c->sgpr64(t3)) >= 0; // bgez t3, L74
|
|
c->mov128_gpr_vf(t3, vf25); // qmfc2.ni t3, vf25
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
c->sb(t1, 3, a3); // sb t1, 3(a3)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(a3, 0, a2); // sw a3, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
|
|
block_4:
|
|
bc = ((s64)c->sgpr64(t4)) >= 0; // bgez t4, L75
|
|
c->daddiu(a3, a3, 4); // daddiu a3, a3, 4
|
|
if (bc) {goto block_6;} // branch non-likely
|
|
|
|
c->sb(t1, 3, a3); // sb t1, 3(a3)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(a3, 0, a2); // sw a3, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
|
|
block_6:
|
|
bc = ((s64)c->sgpr64(t2)) >= 0; // bgez t2, L76
|
|
c->daddiu(a3, a3, 4); // daddiu a3, a3, 4
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
|
|
c->sb(t1, 3, a3); // sb t1, 3(a3)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(a3, 0, a2); // sw a3, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
|
|
block_8:
|
|
bc = ((s64)c->sgpr64(t3)) >= 0; // bgez t3, L77
|
|
c->daddiu(a3, a3, 4); // daddiu a3, a3, 4
|
|
if (bc) {goto block_10;} // branch non-likely
|
|
|
|
c->sb(t1, 3, a3); // sb t1, 3(a3)
|
|
// nop // sll r0, r0, 0
|
|
c->sw(a3, 0, a2); // sw a3, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
|
|
block_10:
|
|
bc = ((s64)c->sgpr64(t0)) > 0; // bgtz t0, L73
|
|
c->daddiu(a3, a3, 4); // daddiu a3, a3, 4
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
|
|
block_11:
|
|
bc = ((s64)c->sgpr64(t0)) <= 0; // blez t0, L81
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_15;} // branch non-likely
|
|
|
|
|
|
block_12:
|
|
c->lbu(t2, 0, a3); // lbu t2, 0(a3)
|
|
c->lbu(t3, 1, a3); // lbu t3, 1(a3)
|
|
c->lbu(t1, 2, a3); // lbu t1, 2(a3)
|
|
c->dsll(t2, t2, 4); // dsll t2, t2, 4
|
|
c->dsll(t3, t3, 4); // dsll t3, t3, 4
|
|
c->dsll(t1, t1, 4); // dsll t1, t1, 4
|
|
c->daddu(t2, t2, a0); // daddu t2, t2, a0
|
|
c->daddu(t3, t3, a0); // daddu t3, t3, a0
|
|
c->daddu(t1, t1, a0); // daddu t1, t1, a0
|
|
c->lqc2(vf2, 0, t2); // lqc2 vf2, 0(t2)
|
|
c->lqc2(vf3, 0, t3); // lqc2 vf3, 0(t3)
|
|
c->lqc2(vf4, 0, t1); // lqc2 vf4, 0(t1)
|
|
c->vsub(DEST::xyzw, vf5, vf3, vf2); // vsub.xyzw vf5, vf3, vf2
|
|
c->vsub(DEST::xyzw, vf6, vf4, vf2); // vsub.xyzw vf6, vf4, vf2
|
|
c->vopmula(vf5, vf6); // vopmula.xyz acc, vf5, vf6
|
|
c->vopmsub(vf5, vf6, vf5); // vopmsub.xyz vf5, vf6, vf5
|
|
c->vmul(DEST::xyz, vf5, vf5, vf1); // vmul.xyz vf5, vf5, vf1
|
|
c->vadd_bc(DEST::y, BC::x, vf5, vf5, vf5); // vaddx.y vf5, vf5, vf5
|
|
c->vadd_bc(DEST::y, BC::z, vf5, vf5, vf5); // vaddz.y vf5, vf5, vf5
|
|
c->mov128_gpr_vf(t1, vf5); // qmfc2.i t1, vf5
|
|
// nop // sll r0, r0, 0
|
|
bc = ((s64)c->sgpr64(t1)) >= 0; // bgez t1, L80
|
|
c->addiu(t1, r0, 1); // addiu t1, r0, 1
|
|
if (bc) {goto block_14;} // branch non-likely
|
|
|
|
c->sw(a3, 0, a2); // sw a3, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
c->sb(t1, 3, a3); // sb t1, 3(a3)
|
|
|
|
block_14:
|
|
c->daddiu(t0, t0, -1); // daddiu t0, t0, -1
|
|
bc = c->sgpr64(t0) != 0; // bne t0, r0, L79
|
|
c->daddiu(a3, a3, 4); // daddiu a3, a3, 4
|
|
if (bc) {goto block_12;} // branch non-likely
|
|
|
|
|
|
block_15:
|
|
c->dsubu(a0, a2, v1); // dsubu a0, a2, v1
|
|
c->dsra(a0, a0, 2); // dsra a0, a0, 2
|
|
c->sw(a0, 20, a1); // sw a0, 20(a1)
|
|
c->sw(v1, 32, a1); // sw v1, 32(a1)
|
|
c->sw(a2, 16, a1); // sw a2, 16(a1)
|
|
c->gprs[v0].du64[0] = 0; // or v0, r0, r0
|
|
c->ld(ra, 0, sp); // ld ra, 0(sp)
|
|
c->lq(gp, 48, sp); // lq gp, 48(sp)
|
|
c->lq(s5, 32, sp); // lq s5, 32(sp)
|
|
c->lq(s4, 16, sp); // lq s4, 16(sp)
|
|
//jr ra // jr ra
|
|
c->daddiu(sp, sp, 64); // daddiu sp, sp, 64
|
|
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() {
|
|
gLinkedFunctionTable.reg("shadow-find-facing-single-tris", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_find_facing_single_tris
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_find_single_edges {
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->lw(a2, 16, a1); // lw a2, 16(a1)
|
|
c->lh(a3, 14, a0); // lh a3, 14(a0)
|
|
c->mov64(v1, a2); // or v1, a2, r0
|
|
c->lw(t0, 32, a0); // lw t0, 32(a0)
|
|
bc = c->sgpr64(a3) == 0; // beq a3, r0, L71
|
|
c->lw(t1, 28, a0); // lw t1, 28(a0)
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
|
|
c->daddu(t0, t0, a0); // daddu t0, t0, a0
|
|
c->sw(a2, 36, a1); // sw a2, 36(a1)
|
|
c->daddu(a0, t1, a0); // daddu a0, t1, a0
|
|
c->sw(t0, 4, a1); // sw t0, 4(a1)
|
|
c->mov64(t1, t0); // or t1, t0, r0
|
|
c->addiu(t2, r0, 255); // addiu t2, r0, 255
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_2:
|
|
c->daddiu(a3, a3, -1); // daddiu a3, a3, -1
|
|
c->lbu(t4, 3, t1); // lbu t4, 3(t1)
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t5, 2, t1); // lbu t5, 2(t1)
|
|
bc = c->sgpr64(t4) == c->sgpr64(t2); // beq t4, t2, L68
|
|
c->gprs[t3].du64[0] = 0; // or t3, r0, r0
|
|
if (bc) {goto block_5;} // branch non-likely
|
|
|
|
c->dsll(t3, t5, 2); // dsll t3, t5, 2
|
|
c->dsll(t4, t4, 2); // dsll t4, t4, 2
|
|
c->daddu(t3, t3, a0); // daddu t3, t3, a0
|
|
c->daddu(t5, t4, a0); // daddu t5, t4, a0
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t4, 3, t3); // lbu t4, 3(t3)
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t5, 3, t5); // lbu t5, 3(t5)
|
|
c->sltiu(t3, t4, 1); // Unknown instr: sltiu t3, t4, 1
|
|
// nop // sll r0, r0, 0
|
|
bc = c->sgpr64(t4) == c->sgpr64(t5); // beq t4, t5, L70
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
//beq r0, r0, L69 // beq r0, r0, L69
|
|
// nop // sll r0, r0, 0
|
|
goto block_6; // branch always
|
|
|
|
|
|
block_5:
|
|
c->dsll(t4, t5, 2); // dsll t4, t5, 2
|
|
// nop // sll r0, r0, 0
|
|
c->daddu(t4, t4, a0); // daddu t4, t4, a0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t4, 3, t4); // lbu t4, 3(t4)
|
|
bc = c->sgpr64(t4) == 0; // beq t4, r0, L70
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
|
|
block_6:
|
|
c->dsubu(t4, t1, t0); // dsubu t4, t1, t0
|
|
c->sh(t3, 2, v1); // sh t3, 2(v1)
|
|
c->sh(t4, 0, v1); // sh t4, 0(v1)
|
|
c->daddiu(v1, v1, 4); // daddiu v1, v1, 4
|
|
|
|
block_7:
|
|
bc = c->sgpr64(a3) != 0; // bne a3, r0, L67
|
|
c->daddiu(t1, t1, 4); // daddiu t1, t1, 4
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
|
|
block_8:
|
|
c->dsubu(a0, v1, a2); // dsubu a0, v1, a2
|
|
c->dsra(a0, a0, 2); // dsra a0, a0, 2
|
|
c->sw(a0, 24, a1); // sw a0, 24(a1)
|
|
c->sw(v1, 16, a1); // sw v1, 16(a1)
|
|
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
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
gLinkedFunctionTable.reg("shadow-find-single-edges", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_find_single_edges
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_find_facing_double_tris {
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->daddiu(sp, sp, -16); // daddiu sp, sp, -16
|
|
c->sd(ra, 0, sp); // sd ra, 0(sp)
|
|
c->lh(a2, 16, a0); // lh a2, 16(a0)
|
|
c->lw(v1, 36, a0); // lw v1, 36(a0)
|
|
c->daddu(a0, v1, a0); // daddu a0, v1, a0
|
|
c->mov64(v1, a0); // or v1, a0, r0
|
|
c->sw(a0, 12, a1); // sw a0, 12(a1)
|
|
c->lqc2(vf1, 128, a1); // lqc2 vf1, 128(a1)
|
|
c->lqc2(vf2, 64, a1); // lqc2 vf2, 64(a1)
|
|
c->lqc2(vf11, 80, a1); // lqc2 vf11, 80(a1)
|
|
c->lw(a0, 0, a1); // lw a0, 0(a1)
|
|
c->pextlw(a0, a0, a0); // pextlw a0, a0, a0
|
|
c->pextlw(a0, a0, a0); // pextlw a0, a0, a0
|
|
c->daddiu(a1, a2, -4); // daddiu a1, a2, -4
|
|
c->addiu(a2, r0, 1); // addiu a2, r0, 1
|
|
bc = ((s64)c->sgpr64(a1)) < 0; // bltz a1, L62
|
|
c->daddiu(a1, a1, 4); // daddiu a1, a1, 4
|
|
if (bc) {goto block_11;} // branch non-likely
|
|
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t0, 0, v1); // lq t0, 0(v1)
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->pextub(a3, r0, t0); // pextub a3, r0, t0
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlb(t0, r0, t0); // pextlb t0, r0, t0
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->psllh(a3, a3, 4); // psllh a3, a3, 4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->psllh(t1, t0, 4); // psllh t1, t0, 4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextuh(t0, r0, t1); // pextuh t0, r0, t1
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlh(t1, r0, t1); // pextlh t1, r0, t1
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextuh(t4, r0, a3); // pextuh t4, r0, a3
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlh(t2, r0, a3); // pextlh t2, r0, a3
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->paddw(t3, t1, a0); // paddw t3, t1, a0
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pcpyud(t1, t3, r0); // pcpyud t1, t3, r0
|
|
c->lq(a3, 0, t3); // lq a3, 0(t3)
|
|
c->paddw(t5, t0, a0); // paddw t5, t0, a0
|
|
c->lq(t0, 0, t1); // lq t0, 0(t1)
|
|
c->pcpyud(t6, t5, r0); // pcpyud t6, t5, r0
|
|
c->lq(t1, 0, t5); // lq t1, 0(t5)
|
|
c->dsra32(t3, t3, 0); // dsra32 t3, t3, 0
|
|
c->dsra32(t5, t5, 0); // dsra32 t5, t5, 0
|
|
c->paddw(t9, t2, a0); // paddw t9, t2, a0
|
|
c->lq(t2, 0, t6); // lq t2, 0(t6)
|
|
c->pcpyud(t6, t9, r0); // pcpyud t6, t9, r0
|
|
c->lq(t3, 0, t3); // lq t3, 0(t3)
|
|
c->paddw(t8, t4, a0); // paddw t8, t4, a0
|
|
c->lq(t4, 0, t5); // lq t4, 0(t5)
|
|
c->pcpyud(t7, t8, r0); // pcpyud t7, t8, r0
|
|
c->lq(t5, 0, t9); // lq t5, 0(t9)
|
|
c->dsra32(t9, t9, 0); // dsra32 t9, t9, 0
|
|
c->dsra32(ra, t8, 0); // dsra32 ra, t8, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t9, 0, t9); // lq t9, 0(t9)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t6, 0, t6); // lq t6, 0(t6)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t8, 0, t8); // lq t8, 0(t8)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(ra, 0, ra); // lq ra, 0(ra)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t7, 0, t7); // lq t7, 0(t7)
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf2, a3); // qmtc2.ni vf2, a3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf3, t3); // qmtc2.ni vf3, t3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf4, t0); // qmtc2.ni vf4, t0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf7, t1); // qmtc2.ni vf7, t1
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf8, t4); // qmtc2.ni vf8, t4
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf9, t2); // qmtc2.ni vf9, t2
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf12, t5); // qmtc2.ni vf12, t5
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf13, t9); // qmtc2.ni vf13, t9
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf14, t6); // qmtc2.ni vf14, t6
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf17, t8); // qmtc2.ni vf17, t8
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf18, ra); // qmtc2.ni vf18, ra
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf19, t7); // qmtc2.ni vf19, t7
|
|
|
|
block_2:
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t0, 16, v1); // lq t0, 16(v1)
|
|
c->daddiu(a1, a1, -4); // daddiu a1, a1, -4
|
|
exec_0(c); // Unknown instr: vcallms 0
|
|
c->pextub(a3, r0, t0); // pextub a3, r0, t0
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlb(t0, r0, t0); // pextlb t0, r0, t0
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->psllh(a3, a3, 4); // psllh a3, a3, 4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->psllh(t1, t0, 4); // psllh t1, t0, 4
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextuh(t0, r0, t1); // pextuh t0, r0, t1
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlh(t1, r0, t1); // pextlh t1, r0, t1
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextuh(t4, r0, a3); // pextuh t4, r0, a3
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pextlh(t2, r0, a3); // pextlh t2, r0, a3
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->paddw(t3, t1, a0); // paddw t3, t1, a0
|
|
c->mfc1(r0, f31); // mfc1 r0, f31
|
|
c->pcpyud(t1, t3, r0); // pcpyud t1, t3, r0
|
|
c->lq(a3, 0, t3); // lq a3, 0(t3)
|
|
c->paddw(t5, t0, a0); // paddw t5, t0, a0
|
|
c->lq(t0, 0, t1); // lq t0, 0(t1)
|
|
c->pcpyud(t6, t5, r0); // pcpyud t6, t5, r0
|
|
c->lq(t1, 0, t5); // lq t1, 0(t5)
|
|
c->dsra32(t3, t3, 0); // dsra32 t3, t3, 0
|
|
c->dsra32(t5, t5, 0); // dsra32 t5, t5, 0
|
|
c->paddw(t9, t2, a0); // paddw t9, t2, a0
|
|
c->lq(t2, 0, t6); // lq t2, 0(t6)
|
|
c->pcpyud(t6, t9, r0); // pcpyud t6, t9, r0
|
|
c->lq(t3, 0, t3); // lq t3, 0(t3)
|
|
c->paddw(t8, t4, a0); // paddw t8, t4, a0
|
|
c->lq(t4, 0, t5); // lq t4, 0(t5)
|
|
c->pcpyud(t7, t8, r0); // pcpyud t7, t8, r0
|
|
c->lq(t5, 0, t9); // lq t5, 0(t9)
|
|
c->dsra32(t9, t9, 0); // dsra32 t9, t9, 0
|
|
c->dsra32(ra, t8, 0); // dsra32 ra, t8, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t9, 0, t9); // lq t9, 0(t9)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t6, 0, t6); // lq t6, 0(t6)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t8, 0, t8); // lq t8, 0(t8)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(ra, 0, ra); // lq ra, 0(ra)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t7, 0, t7); // lq t7, 0(t7)
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf2, a3); // qmtc2.ni vf2, a3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf3, t3); // qmtc2.ni vf3, t3
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf4, t0); // qmtc2.ni vf4, t0
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf7, t1); // qmtc2.ni vf7, t1
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf8, t4); // qmtc2.ni vf8, t4
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf9, t2); // qmtc2.ni vf9, t2
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf12, t5); // qmtc2.ni vf12, t5
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf13, t9); // qmtc2.ni vf13, t9
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf14, t6); // qmtc2.ni vf14, t6
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf17, t8); // qmtc2.ni vf17, t8
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf18, ra); // qmtc2.ni vf18, ra
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_vf_gpr(vf19, t7); // qmtc2.ni vf19, t7
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t0, vf22); // qmfc2.ni t0, vf22
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(t1, vf23); // qmfc2.ni t1, vf23
|
|
// nop // sll r0, r0, 0
|
|
c->mov128_gpr_vf(a3, vf24); // qmfc2.ni a3, vf24
|
|
bc = ((s64)c->sgpr64(t0)) >= 0; // bgez t0, L58
|
|
c->mov128_gpr_vf(t0, vf25); // qmfc2.ni t0, vf25
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
c->sb(a2, 3, v1); // sb a2, 3(v1)
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_4:
|
|
bc = ((s64)c->sgpr64(t1)) >= 0; // bgez t1, L59
|
|
c->daddiu(v1, v1, 4); // daddiu v1, v1, 4
|
|
if (bc) {goto block_6;} // branch non-likely
|
|
|
|
c->sb(a2, 3, v1); // sb a2, 3(v1)
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_6:
|
|
bc = ((s64)c->sgpr64(a3)) >= 0; // bgez a3, L60
|
|
c->daddiu(v1, v1, 4); // daddiu v1, v1, 4
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
|
|
c->sb(a2, 3, v1); // sb a2, 3(v1)
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_8:
|
|
bc = ((s64)c->sgpr64(t0)) >= 0; // bgez t0, L61
|
|
c->daddiu(v1, v1, 4); // daddiu v1, v1, 4
|
|
if (bc) {goto block_10;} // branch non-likely
|
|
|
|
c->sb(a2, 3, v1); // sb a2, 3(v1)
|
|
// nop // sll r0, r0, 0
|
|
|
|
block_10:
|
|
bc = ((s64)c->sgpr64(a1)) > 0; // bgtz a1, L57
|
|
c->daddiu(v1, v1, 4); // daddiu v1, v1, 4
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
|
|
block_11:
|
|
bc = ((s64)c->sgpr64(a1)) <= 0; // blez a1, L65
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_15;} // branch non-likely
|
|
|
|
|
|
block_12:
|
|
c->lbu(a3, 0, v1); // lbu a3, 0(v1)
|
|
c->lbu(t0, 1, v1); // lbu t0, 1(v1)
|
|
c->lbu(a2, 2, v1); // lbu a2, 2(v1)
|
|
c->dsll(a3, a3, 4); // dsll a3, a3, 4
|
|
c->dsll(t0, t0, 4); // dsll t0, t0, 4
|
|
c->dsll(a2, a2, 4); // dsll a2, a2, 4
|
|
c->daddu(a3, a3, a0); // daddu a3, a3, a0
|
|
c->daddu(t0, t0, a0); // daddu t0, t0, a0
|
|
c->daddu(a2, a2, a0); // daddu a2, a2, a0
|
|
c->lqc2(vf2, 0, a3); // lqc2 vf2, 0(a3)
|
|
c->lqc2(vf3, 0, t0); // lqc2 vf3, 0(t0)
|
|
c->lqc2(vf4, 0, a2); // lqc2 vf4, 0(a2)
|
|
c->vsub(DEST::xyzw, vf5, vf3, vf2); // vsub.xyzw vf5, vf3, vf2
|
|
c->vsub(DEST::xyzw, vf6, vf4, vf2); // vsub.xyzw vf6, vf4, vf2
|
|
c->vopmula(vf5, vf6); // vopmula.xyz acc, vf5, vf6
|
|
c->vopmsub(vf5, vf6, vf5); // vopmsub.xyz vf5, vf6, vf5
|
|
c->vmul(DEST::xyz, vf5, vf5, vf1); // vmul.xyz vf5, vf5, vf1
|
|
c->vadd_bc(DEST::y, BC::x, vf5, vf5, vf5); // vaddx.y vf5, vf5, vf5
|
|
c->vadd_bc(DEST::y, BC::z, vf5, vf5, vf5); // vaddz.y vf5, vf5, vf5
|
|
c->mov128_gpr_vf(a2, vf5); // qmfc2.i a2, vf5
|
|
// nop // sll r0, r0, 0
|
|
bc = ((s64)c->sgpr64(a2)) >= 0; // bgez a2, L64
|
|
c->addiu(a2, r0, 1); // addiu a2, r0, 1
|
|
if (bc) {goto block_14;} // branch non-likely
|
|
|
|
c->sb(a2, 3, v1); // sb a2, 3(v1)
|
|
|
|
block_14:
|
|
c->daddiu(a1, a1, -1); // daddiu a1, a1, -1
|
|
bc = c->sgpr64(a1) != 0; // bne a1, r0, L63
|
|
c->daddiu(v1, v1, 4); // daddiu v1, v1, 4
|
|
if (bc) {goto block_12;} // branch non-likely
|
|
|
|
|
|
block_15:
|
|
c->gprs[v0].du64[0] = 0; // or v0, r0, r0
|
|
c->ld(ra, 0, sp); // ld ra, 0(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() {
|
|
gLinkedFunctionTable.reg("shadow-find-facing-double-tris", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_find_facing_double_tris
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_find_double_edges {
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->lw(a2, 16, a1); // lw a2, 16(a1)
|
|
c->lh(a3, 18, a0); // lh a3, 18(a0)
|
|
c->mov64(v1, a2); // or v1, a2, r0
|
|
c->lw(t1, 40, a0); // lw t1, 40(a0)
|
|
bc = c->sgpr64(a3) == 0; // beq a3, r0, L55
|
|
c->lw(t0, 12, a1); // lw t0, 12(a1)
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
c->daddu(a0, t1, a0); // daddu a0, t1, a0
|
|
c->sw(a2, 40, a1); // sw a2, 40(a1)
|
|
c->sw(a0, 8, a1); // sw a0, 8(a1)
|
|
c->mov64(t1, a0); // or t1, a0, r0
|
|
c->addiu(t2, r0, 255); // addiu t2, r0, 255
|
|
|
|
block_2:
|
|
c->daddiu(a3, a3, -1); // daddiu a3, a3, -1
|
|
c->lbu(t3, 3, t1); // lbu t3, 3(t1)
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t4, 2, t1); // lbu t4, 2(t1)
|
|
bc = c->sgpr64(t3) == c->sgpr64(t2); // beq t3, t2, L53
|
|
c->gprs[t5].du64[0] = 0; // or t5, r0, r0
|
|
if (bc) {goto block_5;} // branch non-likely
|
|
|
|
c->dsll(t4, t4, 2); // dsll t4, t4, 2
|
|
c->dsll(t3, t3, 2); // dsll t3, t3, 2
|
|
c->daddu(t4, t4, t0); // daddu t4, t4, t0
|
|
c->daddu(t3, t3, t0); // daddu t3, t3, t0
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t4, 3, t4); // lbu t4, 3(t4)
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t3, 3, t3); // lbu t3, 3(t3)
|
|
bc = c->sgpr64(t4) == c->sgpr64(t3); // beq t4, t3, L54
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_6;} // branch non-likely
|
|
|
|
c->sltiu(t4, t4, 1); // Unknown instr: sltiu t4, t4, 1
|
|
// nop // sll r0, r0, 0
|
|
c->sltu(t3, r0, t3); // sltu t3, r0, t3
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sh(t4, 2, v1); // sh t4, 2(v1)
|
|
c->dsubu(t4, t1, a0); // dsubu t4, t1, a0
|
|
c->sh(t3, 6, v1); // sh t3, 6(v1)
|
|
// nop // sll r0, r0, 0
|
|
c->sh(t4, 0, v1); // sh t4, 0(v1)
|
|
// nop // sll r0, r0, 0
|
|
c->sh(t4, 4, v1); // sh t4, 4(v1)
|
|
//beq r0, r0, L54 // beq r0, r0, L54
|
|
c->daddiu(v1, v1, 8); // daddiu v1, v1, 8
|
|
goto block_6; // branch always
|
|
|
|
|
|
block_5:
|
|
c->dsll(t3, t4, 2); // dsll t3, t4, 2
|
|
// nop // sll r0, r0, 0
|
|
c->daddu(t3, t3, t0); // daddu t3, t3, t0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->lbu(t3, 3, t3); // lbu t3, 3(t3)
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->sltiu(t3, t3, 1); // Unknown instr: sltiu t3, t3, 1
|
|
c->dsubu(t4, t1, a0); // dsubu t4, t1, a0
|
|
c->sh(t3, 2, v1); // sh t3, 2(v1)
|
|
c->sh(t4, 0, v1); // sh t4, 0(v1)
|
|
c->daddiu(v1, v1, 4); // daddiu v1, v1, 4
|
|
|
|
block_6:
|
|
bc = c->sgpr64(a3) != 0; // bne a3, r0, L52
|
|
c->daddiu(t1, t1, 4); // daddiu t1, t1, 4
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
|
|
block_7:
|
|
c->dsubu(a0, v1, a2); // dsubu a0, v1, a2
|
|
c->dsra(a0, a0, 2); // dsra a0, a0, 2
|
|
c->sw(a0, 28, a1); // sw a0, 28(a1)
|
|
c->sw(v1, 16, a1); // sw v1, 16(a1)
|
|
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
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
gLinkedFunctionTable.reg("shadow-find-double-edges", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_find_double_edges
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_add_verts {
|
|
struct Cache {
|
|
void* shadow_data; // *shadow-data*
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->load_symbol(v1, cache.shadow_data); // lw v1, *shadow-data*(s7)
|
|
c->mov64(v1, v1); // or v1, v1, r0
|
|
c->lh(a0, 8, a0); // lh a0, 8(a0)
|
|
c->addiu(t0, r0, 4); // addiu t0, r0, 4
|
|
c->lq(a3, 64, v1); // lq a3, 64(v1)
|
|
// nop // sll r0, r0, 0
|
|
c->sq(a3, 0, a2); // sq a3, 0(a2)
|
|
c->sh(a0, 0, a2); // sh a0, 0(a2)
|
|
c->sb(a0, 14, a2); // sb a0, 14(a2)
|
|
c->sh(t0, 12, a2); // sh t0, 12(a2)
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
c->lw(t2, 0, a1); // lw t2, 0(a1)
|
|
c->sll(v1, a0, 4); // sll v1, a0, 4
|
|
c->mov64(t1, a2); // or t1, a2, r0
|
|
c->mov64(t0, a0); // or t0, a0, r0
|
|
c->daddiu(t3, t0, -4); // daddiu t3, t0, -4
|
|
c->mov64(t1, t1); // or t1, t1, r0
|
|
bc = ((s64)c->sgpr64(t3)) < 0; // bltz t3, L46
|
|
c->mov64(t2, t2); // or t2, t2, r0
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
|
|
block_1:
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t6, 0, t2); // lq t6, 0(t2)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t3, 16, t2); // lq t3, 16(t2)
|
|
c->daddiu(t0, t0, -4); // daddiu t0, t0, -4
|
|
c->lq(t4, 32, t2); // lq t4, 32(t2)
|
|
c->daddiu(t1, t1, 64); // daddiu t1, t1, 64
|
|
c->lq(t5, 48, t2); // lq t5, 48(t2)
|
|
c->daddiu(t2, t2, 64); // daddiu t2, t2, 64
|
|
c->sq(t6, -64, t1); // sq t6, -64(t1)
|
|
c->daddiu(t6, t0, -4); // daddiu t6, t0, -4
|
|
c->sq(t3, -48, t1); // sq t3, -48(t1)
|
|
// nop // sll r0, r0, 0
|
|
c->sq(t4, -32, t1); // sq t4, -32(t1)
|
|
bc = ((s64)c->sgpr64(t6)) >= 0; // bgez t6, L45
|
|
c->sq(t5, -16, t1); // sq t5, -16(t1)
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
|
|
block_2:
|
|
bc = c->sgpr64(t0) == 0; // beq t0, r0, L47
|
|
c->lq(t3, 0, t2); // lq t3, 0(t2)
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
c->daddiu(t2, t2, 16); // daddiu t2, t2, 16
|
|
c->daddiu(t1, t1, 16); // daddiu t1, t1, 16
|
|
c->daddiu(t0, t0, -1); // daddiu t0, t0, -1
|
|
c->sq(t3, -16, t1); // sq t3, -16(t1)
|
|
bc = c->sgpr64(t0) == 0; // beq t0, r0, L47
|
|
c->lq(t3, 0, t2); // lq t3, 0(t2)
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
c->daddiu(t2, t2, 16); // daddiu t2, t2, 16
|
|
c->daddiu(t1, t1, 16); // daddiu t1, t1, 16
|
|
c->daddiu(t0, t0, -1); // daddiu t0, t0, -1
|
|
c->sq(t3, -16, t1); // sq t3, -16(t1)
|
|
bc = c->sgpr64(t0) == 0; // beq t0, r0, L47
|
|
c->lq(t3, 0, t2); // lq t3, 0(t2)
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
c->daddiu(t2, t2, 16); // daddiu t2, t2, 16
|
|
c->daddiu(t1, t1, 16); // daddiu t1, t1, 16
|
|
c->daddiu(t0, t0, -1); // daddiu t0, t0, -1
|
|
c->sq(t3, -16, t1); // sq t3, -16(t1)
|
|
bc = c->sgpr64(t0) == 0; // beq t0, r0, L47
|
|
c->lq(t3, 0, t2); // lq t3, 0(t2)
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
c->daddiu(t2, t2, 16); // daddiu t2, t2, 16
|
|
c->daddiu(t1, t1, 16); // daddiu t1, t1, 16
|
|
c->daddiu(t0, t0, -1); // daddiu t0, t0, -1
|
|
c->sq(t3, -16, t1); // sq t3, -16(t1)
|
|
|
|
block_7:
|
|
c->gprs[t0].du64[0] = 0; // or t0, r0, r0
|
|
c->daddu(a2, a2, v1); // daddu a2, a2, v1
|
|
c->addiu(t0, r0, 174); // addiu t0, r0, 174
|
|
c->sq(a3, 0, a2); // sq a3, 0(a2)
|
|
c->sh(a0, 0, a2); // sh a0, 0(a2)
|
|
c->sb(a0, 14, a2); // sb a0, 14(a2)
|
|
c->sw(r0, 8, a2); // sw r0, 8(a2)
|
|
c->sh(t0, 12, a2); // sh t0, 12(a2)
|
|
c->lw(a3, 44, a1); // lw a3, 44(a1)
|
|
c->daddiu(a1, a2, 16); // daddiu a1, a2, 16
|
|
c->mov64(a2, a1); // or a2, a1, r0
|
|
// nop // sll r0, r0, 0
|
|
c->daddiu(t0, a0, -4); // daddiu t0, a0, -4
|
|
c->mov64(a2, a2); // or a2, a2, r0
|
|
bc = ((s64)c->sgpr64(t0)) < 0; // bltz t0, L49
|
|
c->mov64(a3, a3); // or a3, a3, r0
|
|
if (bc) {goto block_9;} // branch non-likely
|
|
|
|
|
|
block_8:
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t3, 0, a3); // lq t3, 0(a3)
|
|
// nop // sll r0, r0, 0
|
|
c->lq(t0, 16, a3); // lq t0, 16(a3)
|
|
c->daddiu(a0, a0, -4); // daddiu a0, a0, -4
|
|
c->lq(t1, 32, a3); // lq t1, 32(a3)
|
|
c->daddiu(a2, a2, 64); // daddiu a2, a2, 64
|
|
c->lq(t2, 48, a3); // lq t2, 48(a3)
|
|
c->daddiu(a3, a3, 64); // daddiu a3, a3, 64
|
|
c->sq(t3, -64, a2); // sq t3, -64(a2)
|
|
c->daddiu(t3, a0, -4); // daddiu t3, a0, -4
|
|
c->sq(t0, -48, a2); // sq t0, -48(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->sq(t1, -32, a2); // sq t1, -32(a2)
|
|
bc = ((s64)c->sgpr64(t3)) >= 0; // bgez t3, L48
|
|
c->sq(t2, -16, a2); // sq t2, -16(a2)
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
|
|
|
|
block_9:
|
|
bc = c->sgpr64(a0) == 0; // beq a0, r0, L50
|
|
c->lq(t0, 0, a3); // lq t0, 0(a3)
|
|
if (bc) {goto block_14;} // branch non-likely
|
|
|
|
c->daddiu(a3, a3, 16); // daddiu a3, a3, 16
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
c->daddiu(a0, a0, -1); // daddiu a0, a0, -1
|
|
c->sq(t0, -16, a2); // sq t0, -16(a2)
|
|
bc = c->sgpr64(a0) == 0; // beq a0, r0, L50
|
|
c->lq(t0, 0, a3); // lq t0, 0(a3)
|
|
if (bc) {goto block_14;} // branch non-likely
|
|
|
|
c->daddiu(a3, a3, 16); // daddiu a3, a3, 16
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
c->daddiu(a0, a0, -1); // daddiu a0, a0, -1
|
|
c->sq(t0, -16, a2); // sq t0, -16(a2)
|
|
bc = c->sgpr64(a0) == 0; // beq a0, r0, L50
|
|
c->lq(t0, 0, a3); // lq t0, 0(a3)
|
|
if (bc) {goto block_14;} // branch non-likely
|
|
|
|
c->daddiu(a3, a3, 16); // daddiu a3, a3, 16
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
c->daddiu(a0, a0, -1); // daddiu a0, a0, -1
|
|
c->sq(t0, -16, a2); // sq t0, -16(a2)
|
|
bc = c->sgpr64(a0) == 0; // beq a0, r0, L50
|
|
c->lq(t0, 0, a3); // lq t0, 0(a3)
|
|
if (bc) {goto block_14;} // branch non-likely
|
|
|
|
c->daddiu(a3, a3, 16); // daddiu a3, a3, 16
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
c->daddiu(a0, a0, -1); // daddiu a0, a0, -1
|
|
c->sq(t0, -16, a2); // sq t0, -16(a2)
|
|
|
|
block_14:
|
|
c->gprs[a0].du64[0] = 0; // or a0, r0, r0
|
|
c->daddu(v0, a1, v1); // daddu v0, a1, v1
|
|
//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() {
|
|
cache.shadow_data = intern_from_c("*shadow-data*").c();
|
|
gLinkedFunctionTable.reg("shadow-add-verts", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_add_verts
|
|
} // namespace Mips2C
|
|
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_add_facing_single_tris {
|
|
struct Cache {
|
|
void* shadow_data; // *shadow-data*
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->load_symbol(v1, cache.shadow_data); // lw v1, *shadow-data*(s7)
|
|
c->mov64(a3, v1); // or a3, v1, r0
|
|
c->lw(v1, 20, a1); // lw v1, 20(a1)
|
|
c->lw(a0, 32, a1); // lw a0, 32(a1)
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L43
|
|
c->daddiu(a1, v1, 1); // daddiu a1, v1, 1
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
c->daddiu(a1, a1, 3); // daddiu a1, a1, 3
|
|
c->dsra(t0, a1, 2); // dsra t0, a1, 2
|
|
c->dsll(a1, t0, 2); // dsll a1, t0, 2
|
|
c->daddiu(t0, t0, 1); // daddiu t0, t0, 1
|
|
c->ld(t1, 80, a3); // ld t1, 80(a3)
|
|
c->daddu(t0, t1, t0); // daddu t0, t1, t0
|
|
c->lw(a3, 92, a3); // lw a3, 92(a3)
|
|
c->sd(t0, 0, a2); // sd t0, 0(a2)
|
|
c->addiu(t0, r0, 16728); // addiu t0, r0, 16728
|
|
c->sw(r0, 8, a2); // sw r0, 8(a2)
|
|
c->sw(a3, 12, a2); // sw a3, 12(a2)
|
|
c->sb(a1, 14, a2); // sb a1, 14(a2)
|
|
c->dsll(a1, a1, 2); // dsll a1, a1, 2
|
|
c->sh(t0, 12, a2); // sh t0, 12(a2)
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
c->daddu(a1, a2, a1); // daddu a1, a2, a1
|
|
c->sq(r0, -16, a1); // sq r0, -16(a1)
|
|
c->sw(v1, 0, a2); // sw v1, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
|
|
block_2:
|
|
c->lw(a3, 0, a0); // lw a3, 0(a0)
|
|
c->daddiu(a0, a0, 4); // daddiu a0, a0, 4
|
|
c->lw(a3, 0, a3); // lw a3, 0(a3)
|
|
c->daddiu(v1, v1, -1); // daddiu v1, v1, -1
|
|
c->sw(a3, 0, a2); // sw a3, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
bc = ((s64)c->sgpr64(v1)) > 0; // bgtz v1, L42
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
c->mov64(v1, a1); // or v1, a1, r0
|
|
c->lui(a0, 5376); // lui a0, 5376
|
|
c->ori(a0, a0, 2); // ori a0, a0, 2
|
|
c->sq(r0, 0, v1); // sq r0, 0(v1)
|
|
c->sw(a0, 12, v1); // sw a0, 12(v1)
|
|
c->daddiu(a2, v1, 16); // daddiu a2, v1, 16
|
|
|
|
block_4:
|
|
c->mov64(v0, a2); // or v0, a2, 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
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.shadow_data = intern_from_c("*shadow-data*").c();
|
|
gLinkedFunctionTable.reg("shadow-add-facing-single-tris", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_add_facing_single_tris
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_add_single_edges {
|
|
struct Cache {
|
|
void* shadow_data; // *shadow-data*
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->load_symbol(v1, cache.shadow_data); // lw v1, *shadow-data*(s7)
|
|
c->mov64(a3, v1); // or a3, v1, r0
|
|
c->lw(v1, 24, a1); // lw v1, 24(a1)
|
|
c->lw(a0, 36, a1); // lw a0, 36(a1)
|
|
c->lw(a1, 4, a1); // lw a1, 4(a1)
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L40
|
|
c->daddiu(t0, v1, 1); // daddiu t0, v1, 1
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
c->daddiu(t0, t0, 3); // daddiu t0, t0, 3
|
|
c->dsra(t1, t0, 2); // dsra t1, t0, 2
|
|
c->dsll(t0, t1, 2); // dsll t0, t1, 2
|
|
c->daddiu(t1, t1, 1); // daddiu t1, t1, 1
|
|
c->ld(t2, 80, a3); // ld t2, 80(a3)
|
|
c->daddu(t1, t2, t1); // daddu t1, t2, t1
|
|
c->lw(a3, 92, a3); // lw a3, 92(a3)
|
|
c->sd(t1, 0, a2); // sd t1, 0(a2)
|
|
c->addiu(t1, r0, 16984); // addiu t1, r0, 16984
|
|
c->sw(r0, 8, a2); // sw r0, 8(a2)
|
|
c->sw(a3, 12, a2); // sw a3, 12(a2)
|
|
c->sb(t0, 14, a2); // sb t0, 14(a2)
|
|
c->dsll(a3, t0, 2); // dsll a3, t0, 2
|
|
c->sh(t1, 12, a2); // sh t1, 12(a2)
|
|
c->daddiu(t0, a2, 16); // daddiu t0, a2, 16
|
|
c->daddu(a2, t0, a3); // daddu a2, t0, a3
|
|
c->sq(r0, -16, a2); // sq r0, -16(a2)
|
|
c->sw(v1, 0, t0); // sw v1, 0(t0)
|
|
c->daddiu(a3, t0, 4); // daddiu a3, t0, 4
|
|
|
|
block_2:
|
|
c->lh(t1, 0, a0); // lh t1, 0(a0)
|
|
c->lh(t0, 2, a0); // lh t0, 2(a0)
|
|
c->daddiu(a0, a0, 4); // daddiu a0, a0, 4
|
|
c->daddu(t1, t1, a1); // daddu t1, t1, a1
|
|
c->lhu(t1, 0, t1); // lhu t1, 0(t1)
|
|
c->sh(t0, 2, a3); // sh t0, 2(a3)
|
|
c->sh(t1, 0, a3); // sh t1, 0(a3)
|
|
c->daddiu(v1, v1, -1); // daddiu v1, v1, -1
|
|
c->daddiu(a3, a3, 4); // daddiu a3, a3, 4
|
|
bc = ((s64)c->sgpr64(v1)) > 0; // bgtz v1, L39
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
c->mov64(v1, a2); // or v1, a2, r0
|
|
c->lui(a0, 5376); // lui a0, 5376
|
|
c->ori(a0, a0, 4); // ori a0, a0, 4
|
|
c->sq(r0, 0, v1); // sq r0, 0(v1)
|
|
c->sw(a0, 12, v1); // sw a0, 12(v1)
|
|
c->daddiu(a2, v1, 16); // daddiu a2, v1, 16
|
|
|
|
block_4:
|
|
c->mov64(v0, a2); // or v0, a2, 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
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.shadow_data = intern_from_c("*shadow-data*").c();
|
|
gLinkedFunctionTable.reg("shadow-add-single-edges", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_add_single_edges
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_add_double_tris {
|
|
struct Cache {
|
|
void* shadow_data; // *shadow-data*
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->load_symbol(v1, cache.shadow_data); // lw v1, *shadow-data*(s7)
|
|
c->mov64(a3, v1); // or a3, v1, r0
|
|
c->lh(v1, 16, a0); // lh v1, 16(a0)
|
|
c->lw(a0, 12, a1); // lw a0, 12(a1)
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L37
|
|
c->daddiu(a1, v1, 1); // daddiu a1, v1, 1
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
c->daddiu(a1, a1, 3); // daddiu a1, a1, 3
|
|
c->dsra(t0, a1, 2); // dsra t0, a1, 2
|
|
c->dsll(a1, t0, 2); // dsll a1, t0, 2
|
|
c->daddiu(t0, t0, 1); // daddiu t0, t0, 1
|
|
c->ld(t1, 80, a3); // ld t1, 80(a3)
|
|
c->daddu(t0, t1, t0); // daddu t0, t1, t0
|
|
c->lw(a3, 92, a3); // lw a3, 92(a3)
|
|
c->sd(t0, 0, a2); // sd t0, 0(a2)
|
|
c->addiu(t0, r0, 16728); // addiu t0, r0, 16728
|
|
c->sw(r0, 8, a2); // sw r0, 8(a2)
|
|
c->sw(a3, 12, a2); // sw a3, 12(a2)
|
|
c->sb(a1, 14, a2); // sb a1, 14(a2)
|
|
c->dsll(a1, a1, 2); // dsll a1, a1, 2
|
|
c->sh(t0, 12, a2); // sh t0, 12(a2)
|
|
c->daddiu(a2, a2, 16); // daddiu a2, a2, 16
|
|
c->daddu(a1, a2, a1); // daddu a1, a2, a1
|
|
c->sq(r0, -16, a1); // sq r0, -16(a1)
|
|
c->sw(v1, 0, a2); // sw v1, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
|
|
block_2:
|
|
c->lw(a3, 0, a0); // lw a3, 0(a0)
|
|
c->daddiu(a0, a0, 4); // daddiu a0, a0, 4
|
|
c->daddiu(v1, v1, -1); // daddiu v1, v1, -1
|
|
c->sw(a3, 0, a2); // sw a3, 0(a2)
|
|
c->daddiu(a2, a2, 4); // daddiu a2, a2, 4
|
|
bc = ((s64)c->sgpr64(v1)) > 0; // bgtz v1, L36
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
c->mov64(v1, a1); // or v1, a1, r0
|
|
c->lui(a0, 5376); // lui a0, 5376
|
|
c->ori(a0, a0, 6); // ori a0, a0, 6
|
|
c->sq(r0, 0, v1); // sq r0, 0(v1)
|
|
c->sw(a0, 12, v1); // sw a0, 12(v1)
|
|
c->daddiu(a2, v1, 16); // daddiu a2, v1, 16
|
|
|
|
block_4:
|
|
c->mov64(v0, a2); // or v0, a2, 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() {
|
|
cache.shadow_data = intern_from_c("*shadow-data*").c();
|
|
gLinkedFunctionTable.reg("shadow-add-double-tris", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_add_double_tris
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_add_double_edges {
|
|
struct Cache {
|
|
void* shadow_data; // *shadow-data*
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
c->load_symbol(v1, cache.shadow_data); // lw v1, *shadow-data*(s7)
|
|
c->mov64(a3, v1); // or a3, v1, r0
|
|
c->lw(v1, 28, a1); // lw v1, 28(a1)
|
|
c->lw(a0, 40, a1); // lw a0, 40(a1)
|
|
c->lw(a1, 8, a1); // lw a1, 8(a1)
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L34
|
|
c->daddiu(t0, v1, 1); // daddiu t0, v1, 1
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
c->daddiu(t0, t0, 3); // daddiu t0, t0, 3
|
|
c->dsra(t1, t0, 2); // dsra t1, t0, 2
|
|
c->dsll(t0, t1, 2); // dsll t0, t1, 2
|
|
c->daddiu(t1, t1, 1); // daddiu t1, t1, 1
|
|
c->ld(t2, 80, a3); // ld t2, 80(a3)
|
|
c->daddu(t1, t2, t1); // daddu t1, t2, t1
|
|
c->lw(a3, 92, a3); // lw a3, 92(a3)
|
|
c->sd(t1, 0, a2); // sd t1, 0(a2)
|
|
c->addiu(t1, r0, 16984); // addiu t1, r0, 16984
|
|
c->sw(r0, 8, a2); // sw r0, 8(a2)
|
|
c->sw(a3, 12, a2); // sw a3, 12(a2)
|
|
c->sb(t0, 14, a2); // sb t0, 14(a2)
|
|
c->dsll(a3, t0, 2); // dsll a3, t0, 2
|
|
c->sh(t1, 12, a2); // sh t1, 12(a2)
|
|
c->daddiu(t0, a2, 16); // daddiu t0, a2, 16
|
|
c->daddu(a2, t0, a3); // daddu a2, t0, a3
|
|
c->sq(r0, -16, a2); // sq r0, -16(a2)
|
|
c->sw(v1, 0, t0); // sw v1, 0(t0)
|
|
c->daddiu(a3, t0, 4); // daddiu a3, t0, 4
|
|
|
|
block_2:
|
|
c->lh(t1, 0, a0); // lh t1, 0(a0)
|
|
c->lh(t0, 2, a0); // lh t0, 2(a0)
|
|
c->daddiu(a0, a0, 4); // daddiu a0, a0, 4
|
|
c->daddu(t1, t1, a1); // daddu t1, t1, a1
|
|
c->lhu(t1, 0, t1); // lhu t1, 0(t1)
|
|
c->sh(t0, 2, a3); // sh t0, 2(a3)
|
|
c->sh(t1, 0, a3); // sh t1, 0(a3)
|
|
c->daddiu(v1, v1, -1); // daddiu v1, v1, -1
|
|
c->daddiu(a3, a3, 4); // daddiu a3, a3, 4
|
|
bc = ((s64)c->sgpr64(v1)) > 0; // bgtz v1, L33
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_2;} // branch non-likely
|
|
|
|
c->mov64(v1, a2); // or v1, a2, r0
|
|
c->lui(a0, 5376); // lui a0, 5376
|
|
c->ori(a0, a0, 4); // ori a0, a0, 4
|
|
c->sq(r0, 0, v1); // sq r0, 0(v1)
|
|
c->sw(a0, 12, v1); // sw a0, 12(v1)
|
|
c->daddiu(a2, v1, 16); // daddiu a2, v1, 16
|
|
|
|
block_4:
|
|
c->mov64(v0, a2); // or v0, a2, 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
|
|
// nop // sll r0, r0, 0
|
|
end_of_function:
|
|
return c->gprs[v0].du64[0];
|
|
}
|
|
|
|
void link() {
|
|
cache.shadow_data = intern_from_c("*shadow-data*").c();
|
|
gLinkedFunctionTable.reg("shadow-add-double-edges", execute, 128);
|
|
}
|
|
|
|
} // namespace shadow_add_double_edges
|
|
} // namespace Mips2C
|
|
|
|
//--------------------------MIPS2C---------------------
|
|
#include "game/mips2c/mips2c_private.h"
|
|
|
|
namespace Mips2C::jak1 {
|
|
namespace shadow_execute {
|
|
struct Cache {
|
|
void* fake_scratchpad_data; // *fake-scratchpad-data*
|
|
void* gsf_buffer; // *gsf-buffer*
|
|
void* math_camera; // *math-camera*
|
|
void* camera_pos; // camera-pos
|
|
void* flush_cache; // flush-cache
|
|
void* shadow_add_double_edges; // shadow-add-double-edges
|
|
void* shadow_add_double_tris; // shadow-add-double-tris
|
|
void* shadow_add_facing_single_tris; // shadow-add-facing-single-tris
|
|
void* shadow_add_single_edges; // shadow-add-single-edges
|
|
void* shadow_add_verts; // shadow-add-verts
|
|
void* shadow_calc_dual_verts; // shadow-calc-dual-verts
|
|
void* shadow_find_double_edges; // shadow-find-double-edges
|
|
void* shadow_find_facing_double_tris; // shadow-find-facing-double-tris
|
|
void* shadow_find_facing_single_tris; // shadow-find-facing-single-tris
|
|
void* shadow_find_single_edges; // shadow-find-single-edges
|
|
void* shadow_init_vars; // shadow-init-vars
|
|
void* shadow_scissor_edges; // shadow-scissor-edges
|
|
void* shadow_scissor_top; // shadow-scissor-top
|
|
void* shadow_xform_verts; // shadow-xform-verts
|
|
} cache;
|
|
|
|
u64 execute(void* ctxt) {
|
|
u32 sadr, tadr;
|
|
auto* c = (ExecutionContext*)ctxt;
|
|
bool bc = false;
|
|
u32 call_addr = 0;
|
|
bool cop1_bc = false;
|
|
c->daddiu(sp, sp, -112); // daddiu sp, sp, -112
|
|
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(s1, 16, sp); // sq s1, 16(sp)
|
|
c->sq(s2, 32, sp); // sq s2, 32(sp)
|
|
c->sq(s3, 48, sp); // sq s3, 48(sp)
|
|
c->sq(s4, 64, sp); // sq s4, 64(sp)
|
|
c->sq(s5, 80, sp); // sq s5, 80(sp)
|
|
c->sq(gp, 96, sp); // sq gp, 96(sp)
|
|
c->mov64(gp, a1); // or gp, a1, r0
|
|
c->mov64(s4, a0); // or s4, a0, r0
|
|
c->addiu(v1, r0, 0); // addiu v1, r0, 0
|
|
get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
|
|
c->daddiu(s5, v1, 124); // daddiu s5, v1, 124
|
|
c->load_symbol(t9, cache.flush_cache); // lw t9, flush-cache(s7)
|
|
c->addiu(a0, r0, 0); // addiu a0, r0, 0
|
|
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
|
|
//beq r0, r0, L31 // beq r0, r0, L31
|
|
// nop // sll r0, r0, 0
|
|
goto block_24; // branch always
|
|
|
|
|
|
block_1:
|
|
c->lui(v1, 4096); // lui v1, 4096
|
|
c->ori(v1, v1, 54272); // ori v1, v1, 54272 0xd400, spr to
|
|
c->addiu(a0, r0, 128); // addiu a0, r0, 128
|
|
c->mov64(a1, v1); // or a1, v1, r0
|
|
|
|
/*
|
|
block_2:
|
|
c->lw(a2, 0, a1); // lw a2, 0(a1)
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
c->andi(a2, a2, 256); // andi a2, a2, 256
|
|
// nop // sll r0, r0, 0
|
|
bc = c->sgpr64(a2) == 0; // beq a2, r0, L20
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_4;} // branch non-likely
|
|
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
// nop // sll r0, r0, 0
|
|
//beq r0, r0, L19 // beq r0, r0, L19
|
|
// nop // sll r0, r0, 0
|
|
goto block_2; // branch always
|
|
*/
|
|
|
|
/*
|
|
block_4:
|
|
c->gprs[a1].du64[0] = 0; // or a1, r0, r0
|
|
c->mov64(a1, v1); // or a1, v1, r0
|
|
c->mov64(a2, s5); // or a2, s5, r0
|
|
c->lw(a3, 0, a1); // lw a3, 0(a1)
|
|
c->andi(a3, a3, 256); // andi a3, a3, 256
|
|
bc = c->sgpr64(a3) == 0; // beq a3, r0, L22
|
|
// DANGER jump to delay slot, this MUST be fixed manually!
|
|
c->lw(a3, 0, a2); // lw a3, 0(a2)
|
|
if (bc) {goto block_7;} // branch non-likely
|
|
|
|
|
|
block_5:
|
|
c->lw(a3, 0, a2); // lw a3, 0(a2)
|
|
// nop // sll r0, r0, 0
|
|
c->lw(t0, 0, a1); // lw t0, 0(a1)
|
|
// nop // sll r0, r0, 0
|
|
c->andi(t0, t0, 256); // andi t0, t0, 256
|
|
c->daddiu(a3, a3, 1); // daddiu a3, a3, 1
|
|
bc = c->sgpr64(t0) != 0; // bne t0, r0, L21
|
|
c->sw(a3, 0, a2); // sw a3, 0(a2)
|
|
if (bc) {goto block_5;} // branch non-likely
|
|
*/
|
|
|
|
c->gprs[a1].du64[0] = 0; // or a1, r0, r0
|
|
sadr = c->sgpr64(a0); // c->sw(a0, 128, v1); // sw a0, 128(v1)
|
|
tadr = c->sgpr64(s4); // c->sw(s4, 48, v1); // sw s4, 48(v1)
|
|
// c->sw(r0, 32, v1); // sw r0, 32(v1)
|
|
// Unknown instr: sync.l
|
|
c->addiu(a0, r0, 324); // addiu a0, r0, 324
|
|
// c->sw(a0, 0, v1); // sw a0, 0(v1)
|
|
spad_to_dma_blerc_chain(cache.fake_scratchpad_data, sadr, tadr);
|
|
// Unknown instr: sync.l
|
|
c->mov64(a0, s5); // or a0, s5, r0
|
|
/*
|
|
c->lw(a1, 0, v1); // lw a1, 0(v1)
|
|
c->andi(a1, a1, 256); // andi a1, a1, 256
|
|
bc = c->sgpr64(a1) == 0; // beq a1, r0, L24
|
|
// DANGER jump to delay slot, this MUST be fixed manually!
|
|
c->lw(a1, 0, a0); // lw a1, 0(a0)
|
|
if (bc) {goto block_10;} // branch non-likely
|
|
|
|
|
|
block_8:
|
|
c->lw(a1, 0, a0); // lw a1, 0(a0)
|
|
// nop // sll r0, r0, 0
|
|
c->lw(a2, 0, v1); // lw a2, 0(v1)
|
|
// nop // sll r0, r0, 0
|
|
c->andi(a2, a2, 256); // andi a2, a2, 256
|
|
c->daddiu(a1, a1, 1); // daddiu a1, a1, 1
|
|
bc = c->sgpr64(a2) != 0; // bne a2, r0, L23
|
|
c->sw(a1, 0, a0); // sw a1, 0(a0)
|
|
if (bc) {goto block_8;} // branch non-likely
|
|
*/
|
|
|
|
c->gprs[v1].du64[0] = 0; // or v1, r0, r0
|
|
get_fake_spad_addr(at, cache.fake_scratchpad_data, 0, c);// lui at, 28672
|
|
c->addiu(v1, r0, 240); // addiu v1, r0, 240
|
|
c->daddu(s4, v1, at); // daddu s4, v1, at
|
|
c->load_symbol(s3, cache.gsf_buffer); // lw s3, *gsf-buffer*(s7)
|
|
c->daddiu(s2, at, 144); // daddiu s2, at, 144
|
|
// nop // sll r0, r0, 0
|
|
c->lw(v1, 12, s2); // lw v1, 12(s2)
|
|
c->andi(v1, v1, 32); // andi v1, v1, 32
|
|
bc = c->sgpr64(v1) != 0; // bne v1, r0, L30
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_23;} // branch non-likely
|
|
|
|
c->lwc1(f0, 0, s2); // lwc1 f0, 0(s2)
|
|
c->lwc1(f1, 16, s2); // lwc1 f1, 16(s2)
|
|
c->lwc1(f2, 28, s2); // lwc1 f2, 28(s2)
|
|
c->muls(f1, f1, f2); // mul.s f1, f1, f2
|
|
c->adds(f0, f0, f1); // add.s f0, f0, f1
|
|
c->swc1(f0, 64, s3); // swc1 f0, 64(s3)
|
|
c->lwc1(f0, 4, s2); // lwc1 f0, 4(s2)
|
|
c->lwc1(f1, 20, s2); // lwc1 f1, 20(s2)
|
|
c->lwc1(f2, 28, s2); // lwc1 f2, 28(s2)
|
|
c->muls(f1, f1, f2); // mul.s f1, f1, f2
|
|
c->adds(f0, f0, f1); // add.s f0, f0, f1
|
|
c->swc1(f0, 68, s3); // swc1 f0, 68(s3)
|
|
c->lwc1(f0, 8, s2); // lwc1 f0, 8(s2)
|
|
c->lwc1(f1, 24, s2); // lwc1 f1, 24(s2)
|
|
c->lwc1(f2, 28, s2); // lwc1 f2, 28(s2)
|
|
c->muls(f1, f1, f2); // mul.s f1, f1, f2
|
|
c->adds(f0, f0, f1); // add.s f0, f0, f1
|
|
c->swc1(f0, 72, s3); // swc1 f0, 72(s3)
|
|
c->fprs[f0] = 1.0; // lwc1 f0, L127(fp)
|
|
c->swc1(f0, 76, s3); // swc1 f0, 76(s3)
|
|
c->lw(v1, 12, s2); // lw v1, 12(s2)
|
|
c->andi(v1, v1, 4); // andi v1, v1, 4
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L25
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_13;} // branch non-likely
|
|
|
|
c->lq(v1, 32, s2); // lq v1, 32(s2)
|
|
c->sq(v1, 80, s3); // sq v1, 80(s3)
|
|
c->lq(v1, 48, s2); // lq v1, 48(s2)
|
|
c->sq(v1, 96, s3); // sq v1, 96(s3)
|
|
//beq r0, r0, L26 // beq r0, r0, L26
|
|
// nop // sll r0, r0, 0
|
|
goto block_14; // branch always
|
|
|
|
|
|
block_13:
|
|
c->lwc1(f0, 32, s2); // lwc1 f0, 32(s2)
|
|
c->swc1(f0, 80, s3); // swc1 f0, 80(s3)
|
|
c->lwc1(f0, 36, s2); // lwc1 f0, 36(s2)
|
|
c->swc1(f0, 84, s3); // swc1 f0, 84(s3)
|
|
c->lwc1(f0, 40, s2); // lwc1 f0, 40(s2)
|
|
c->swc1(f0, 88, s3); // swc1 f0, 88(s3)
|
|
c->lwc1(f0, 44, s2); // lwc1 f0, 44(s2)
|
|
c->lwc1(f1, 4, s2); // lwc1 f1, 4(s2)
|
|
c->subs(f0, f0, f1); // sub.s f0, f0, f1
|
|
c->swc1(f0, 92, s3); // swc1 f0, 92(s3)
|
|
c->lwc1(f0, 48, s2); // lwc1 f0, 48(s2)
|
|
c->swc1(f0, 96, s3); // swc1 f0, 96(s3)
|
|
c->lwc1(f0, 52, s2); // lwc1 f0, 52(s2)
|
|
c->swc1(f0, 100, s3); // swc1 f0, 100(s3)
|
|
c->lwc1(f0, 56, s2); // lwc1 f0, 56(s2)
|
|
c->swc1(f0, 104, s3); // swc1 f0, 104(s3)
|
|
c->lwc1(f0, 60, s2); // lwc1 f0, 60(s2)
|
|
c->lwc1(f1, 4, s2); // lwc1 f1, 4(s2)
|
|
c->subs(f0, f0, f1); // sub.s f0, f0, f1
|
|
c->swc1(f0, 108, s3); // swc1 f0, 108(s3)
|
|
c->mfc1(v1, f0); // mfc1 v1, f0
|
|
|
|
block_14:
|
|
c->mov64(s1, s7); // or s1, s7, r0
|
|
c->lw(v1, 12, s2); // lw v1, 12(s2)
|
|
c->andi(v1, v1, 1); // andi v1, v1, 1
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L27
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_17;} // branch non-likely
|
|
|
|
c->load_symbol(t9, cache.camera_pos); // lw t9, camera-pos(s7)
|
|
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->lwc1(f0, 0, v1); // lwc1 f0, 0(v1)
|
|
c->lwc1(f1, 80, s3); // lwc1 f1, 80(s3)
|
|
c->muls(f0, f0, f1); // mul.s f0, f0, f1
|
|
c->lwc1(f1, 4, v1); // lwc1 f1, 4(v1)
|
|
c->lwc1(f2, 84, s3); // lwc1 f2, 84(s3)
|
|
c->muls(f1, f1, f2); // mul.s f1, f1, f2
|
|
c->adds(f0, f0, f1); // add.s f0, f0, f1
|
|
c->lwc1(f1, 8, v1); // lwc1 f1, 8(v1)
|
|
c->lwc1(f2, 88, s3); // lwc1 f2, 88(s3)
|
|
c->muls(f1, f1, f2); // mul.s f1, f1, f2
|
|
c->adds(f0, f0, f1); // add.s f0, f0, f1
|
|
c->lwc1(f1, 92, s3); // lwc1 f1, 92(s3)
|
|
c->adds(f0, f0, f1); // add.s f0, f0, f1
|
|
c->mtc1(f1, r0); // mtc1 f1, r0
|
|
cop1_bc = c->fprs[f0] < c->fprs[f1]; // c.lt.s f0, f1
|
|
bc = !cop1_bc; // bc1f L27
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_17;} // branch non-likely
|
|
|
|
c->daddiu(s1, s7, 8); // daddiu s1, s7, #t
|
|
c->mov64(v1, s1); // or v1, s1, r0
|
|
|
|
block_17:
|
|
bc = c->sgpr64(s7) != c->sgpr64(s1); // bne s7, s1, L30
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_23;} // branch non-likely
|
|
|
|
c->lwc1(f0, 64, s3); // lwc1 f0, 64(s3)
|
|
c->lwc1(f1, 80, s3); // lwc1 f1, 80(s3)
|
|
c->muls(f0, f0, f1); // mul.s f0, f0, f1
|
|
c->lwc1(f1, 68, s3); // lwc1 f1, 68(s3)
|
|
c->lwc1(f2, 84, s3); // lwc1 f2, 84(s3)
|
|
c->muls(f1, f1, f2); // mul.s f1, f1, f2
|
|
c->adds(f0, f0, f1); // add.s f0, f0, f1
|
|
c->lwc1(f1, 72, s3); // lwc1 f1, 72(s3)
|
|
c->lwc1(f2, 88, s3); // lwc1 f2, 88(s3)
|
|
c->muls(f1, f1, f2); // mul.s f1, f1, f2
|
|
c->adds(f0, f0, f1); // add.s f0, f0, f1
|
|
c->mtc1(f1, r0); // mtc1 f1, r0
|
|
c->lwc1(f2, 92, s3); // lwc1 f2, 92(s3)
|
|
c->adds(f2, f0, f2); // add.s f2, f0, f2
|
|
cop1_bc = c->fprs[f1] < c->fprs[f2]; // c.lt.s f1, f2
|
|
bc = !cop1_bc; // bc1f L28
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_20;} // branch non-likely
|
|
|
|
c->negs(f0, f0); // neg.s f0, f0
|
|
c->swc1(f0, 92, s3); // swc1 f0, 92(s3)
|
|
c->mfc1(v1, f0); // mfc1 v1, f0
|
|
|
|
block_20:
|
|
c->lq(v1, 16, s2); // lq v1, 16(s2)
|
|
c->sq(v1, 128, s3); // sq v1, 128(s3)
|
|
c->mtc1(f0, r0); // mtc1 f0, r0
|
|
c->swc1(f0, 112, s3); // swc1 f0, 112(s3)
|
|
c->mtc1(f0, r0); // mtc1 f0, r0
|
|
c->swc1(f0, 116, s3); // swc1 f0, 116(s3)
|
|
c->fprs[f0] = 1.0; // lwc1 f0, L127(fp)
|
|
c->swc1(f0, 120, s3); // swc1 f0, 120(s3)
|
|
c->fprs[f0] = -2.0; // lwc1 f0, L126(fp)
|
|
c->load_symbol(v1, cache.math_camera); // lw v1, *math-camera*(s7)
|
|
c->lwc1(f1, 0, v1); // lwc1 f1, 0(v1)
|
|
c->muls(f0, f0, f1); // mul.s f0, f0, f1
|
|
c->swc1(f0, 124, s3); // swc1 f0, 124(s3)
|
|
c->daddiu(v1, s3, 160); // daddiu v1, s3, 160
|
|
c->sw(v1, 16, s3); // sw v1, 16(s3)
|
|
c->load_symbol(t9, cache.shadow_xform_verts); // lw t9, shadow-xform-verts(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_xform_verts::execute(c);
|
|
c->load_symbol(t9, cache.shadow_init_vars); // lw t9, shadow-init-vars(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_init_vars::execute(c);
|
|
c->load_symbol(t9, cache.shadow_calc_dual_verts); // lw t9, shadow-calc-dual-verts(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_calc_dual_verts::execute(c);
|
|
c->lw(v1, 12, s2); // lw v1, 12(s2)
|
|
c->andi(v1, v1, 8); // andi v1, v1, 8
|
|
bc = c->sgpr64(v1) == 0; // beq v1, r0, L29
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
if (bc) {goto block_22;} // branch non-likely
|
|
|
|
c->load_symbol(t9, cache.shadow_scissor_top); // lw t9, shadow-scissor-top(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_scissor_top::execute(c);
|
|
c->mov64(v1, v0); // or v1, v0, r0
|
|
|
|
block_22:
|
|
c->load_symbol(t9, cache.shadow_scissor_edges); // lw t9, shadow-scissor-edges(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_scissor_edges::execute(c);
|
|
c->load_symbol(t9, cache.shadow_find_facing_single_tris);// lw t9, shadow-find-facing-single-tris(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_find_facing_single_tris::execute(c);
|
|
c->load_symbol(t9, cache.shadow_find_single_edges);// lw t9, shadow-find-single-edges(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_find_single_edges::execute(c);
|
|
c->load_symbol(t9, cache.shadow_find_facing_double_tris);// lw t9, shadow-find-facing-double-tris(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_find_facing_double_tris::execute(c);
|
|
c->load_symbol(t9, cache.shadow_find_double_edges);// lw t9, shadow-find-double-edges(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_find_double_edges::execute(c);
|
|
c->load_symbol(t9, cache.shadow_add_verts); // lw t9, shadow-add-verts(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, r0
|
|
c->mov64(a2, gp); // or a2, gp, 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
|
|
shadow_add_verts::execute(c);
|
|
c->mov64(a2, v0); // or a2, v0, r0
|
|
c->load_symbol(t9, cache.shadow_add_facing_single_tris);// lw t9, shadow-add-facing-single-tris(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_add_facing_single_tris::execute(c);
|
|
c->mov64(a2, v0); // or a2, v0, r0
|
|
c->load_symbol(t9, cache.shadow_add_single_edges);// lw t9, shadow-add-single-edges(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_add_single_edges::execute(c);
|
|
c->mov64(a2, v0); // or a2, v0, r0
|
|
c->load_symbol(t9, cache.shadow_add_double_tris); // lw t9, shadow-add-double-tris(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_add_double_tris::execute(c);
|
|
c->mov64(a2, v0); // or a2, v0, r0
|
|
c->load_symbol(t9, cache.shadow_add_double_edges);// lw t9, shadow-add-double-edges(s7)
|
|
c->mov64(a0, s4); // or a0, s4, r0
|
|
c->mov64(a1, s3); // or a1, s3, 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
|
|
shadow_add_double_edges::execute(c);
|
|
c->mov64(gp, v0); // or gp, v0, r0
|
|
c->mov64(v1, gp); // or v1, gp, r0
|
|
|
|
block_23:
|
|
c->lw(s4, 140, at); // lw s4, 140(at)
|
|
|
|
block_24:
|
|
bc = c->sgpr64(s4) != 0; // bne s4, r0, L18
|
|
// nop // sll r0, r0, 0
|
|
if (bc) {goto block_1;} // branch non-likely
|
|
|
|
c->mov64(v1, s7); // or v1, s7, r0
|
|
c->mov64(v0, gp); // or v0, gp, r0
|
|
c->ld(ra, 0, sp); // ld ra, 0(sp)
|
|
c->ld(fp, 8, sp); // ld fp, 8(sp)
|
|
c->lq(gp, 96, sp); // lq gp, 96(sp)
|
|
c->lq(s5, 80, sp); // lq s5, 80(sp)
|
|
c->lq(s4, 64, sp); // lq s4, 64(sp)
|
|
c->lq(s3, 48, sp); // lq s3, 48(sp)
|
|
c->lq(s2, 32, sp); // lq s2, 32(sp)
|
|
c->lq(s1, 16, sp); // lq s1, 16(sp)
|
|
//jr ra // jr ra
|
|
c->daddiu(sp, sp, 112); // daddiu sp, sp, 112
|
|
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() {
|
|
cache.fake_scratchpad_data = intern_from_c("*fake-scratchpad-data*").c();
|
|
cache.gsf_buffer = intern_from_c("*gsf-buffer*").c();
|
|
cache.math_camera = intern_from_c("*math-camera*").c();
|
|
cache.camera_pos = intern_from_c("camera-pos").c();
|
|
cache.flush_cache = intern_from_c("flush-cache").c();
|
|
cache.shadow_add_double_edges = intern_from_c("shadow-add-double-edges").c();
|
|
cache.shadow_add_double_tris = intern_from_c("shadow-add-double-tris").c();
|
|
cache.shadow_add_facing_single_tris = intern_from_c("shadow-add-facing-single-tris").c();
|
|
cache.shadow_add_single_edges = intern_from_c("shadow-add-single-edges").c();
|
|
cache.shadow_add_verts = intern_from_c("shadow-add-verts").c();
|
|
cache.shadow_calc_dual_verts = intern_from_c("shadow-calc-dual-verts").c();
|
|
cache.shadow_find_double_edges = intern_from_c("shadow-find-double-edges").c();
|
|
cache.shadow_find_facing_double_tris = intern_from_c("shadow-find-facing-double-tris").c();
|
|
cache.shadow_find_facing_single_tris = intern_from_c("shadow-find-facing-single-tris").c();
|
|
cache.shadow_find_single_edges = intern_from_c("shadow-find-single-edges").c();
|
|
cache.shadow_init_vars = intern_from_c("shadow-init-vars").c();
|
|
cache.shadow_scissor_edges = intern_from_c("shadow-scissor-edges").c();
|
|
cache.shadow_scissor_top = intern_from_c("shadow-scissor-top").c();
|
|
cache.shadow_xform_verts = intern_from_c("shadow-xform-verts").c();
|
|
gLinkedFunctionTable.reg("shadow-execute", execute, 256);
|
|
}
|
|
|
|
} // namespace shadow_execute
|
|
} // namespace Mips2C
|