//--------------------------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