diff --git a/decompiler/analysis/mips2c.cpp b/decompiler/analysis/mips2c.cpp index 9d0cf18084..5300630aa4 100644 --- a/decompiler/analysis/mips2c.cpp +++ b/decompiler/analysis/mips2c.cpp @@ -1020,6 +1020,7 @@ Mips2C_Line handle_normal_instr(Mips2C_Output& output, case InstructionKind::PSRAH: case InstructionKind::PSRLH: case InstructionKind::PSLLW: + case InstructionKind::PSLLH: return handle_generic_op2_u16(i0, instr_str); case InstructionKind::SLL: return handle_sll(i0, instr_str); diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc index d82f0ac16c..bdef22be8c 100644 --- a/decompiler/config/all-types.gc +++ b/decompiler/config/all-types.gc @@ -526,6 +526,7 @@ (bucket-45 45) (bucket-46 46) + (shadow 47) (pris-tex0 48) (bucket-49 49) (bucket-50 50) @@ -9026,6 +9027,7 @@ (fade-start float :offset-assert 68) (dummy-2 int32 :offset-assert 72) (dummy-3 int32 :offset-assert 76) + (fade-vec vector :inline :offset 64) ;; added ) :method-count-assert 9 :size-assert #x50 @@ -9045,8 +9047,8 @@ (set-top-plane-offset (shadow-control float) int 11) (set-bottom-plane-offset (shadow-control float) int 12) (dummy-13 (_type_) none 13) - (dummy-14 (_type_) none 14) - (dummy-15 (_type_ vector float float float) none 15) + (update-direction-from-time-of-day (_type_) none 14) + (collide-to-find-planes (_type_ vector float float float) none 15) ) ) @@ -9055,9 +9057,9 @@ (texscale vector :inline :offset-assert 16) (clrs vector 2 :inline :offset-assert 32) (dma-unpack-template dma-packet :inline :offset-assert 64) - (dma-cnt uint64 :offset-assert 80) - (vif-nop uint32 :offset-assert 88) - (vif-unpack-v4-8 uint32 :offset-assert 92) + (dma-cnt dma-tag :offset-assert 80) + (vif-nop vif-tag :offset-assert 88) + (vif-unpack-v4-8 vif-tag :offset-assert 92) (pdc basic :offset-assert 96) (dist float :offset-assert 100) (oddeven uint8 :offset-assert 104) @@ -9078,8 +9080,8 @@ ) (deftype shadow-run (structure) - ((first uint32 :offset-assert 0) - (next uint32 :offset-assert 4) + ((first dma-packet :offset-assert 0) + (next (pointer dma-packet) :offset-assert 4) ) :allow-misaligned :method-count-assert 9 @@ -13651,7 +13653,8 @@ ) (deftype foreground-area (structure) - ((joint-work joint-work :inline :offset-assert 0 :score 1999999999) + ( + (joint-work joint-work :inline :offset-assert 0 :score 1999999999) (generic-work generic-work :inline :offset 0) (bone-mem bone-memory :inline :offset 0) (shadow-work shadow-work :inline :offset 0) @@ -16642,7 +16645,7 @@ (define-extern dump-qword (function qword none)) (define-extern bones-debug (function none)) (define-extern dump-bone-mem (function none)) -(define-extern draw-bones-shadow (function draw-control object object pointer)) +(define-extern draw-bones-shadow (function draw-control pointer pointer pointer)) (define-extern draw-bones-generic-merc (function draw-control pointer pointer int pointer)) (define-extern draw-bones-merc (function draw-control object object int int pointer)) (define-extern draw-bones-check-longest-edge (function draw-control float none)) @@ -16860,10 +16863,10 @@ ;; - Functions -(define-extern shadow-vu0-upload function) -(define-extern shadow-dma-init function) -(define-extern shadow-execute function) -(define-extern shadow-dma-end function) +(define-extern shadow-vu0-upload (function none)) +(define-extern shadow-dma-init (function dma-buffer none)) +(define-extern shadow-execute (function shadow-dma-packet pointer pointer)) +(define-extern shadow-dma-end (function dma-buffer none)) (define-extern shadow-vu1-init-buffer (function dma-buffer none)) (define-extern shadow-xform-verts function) (define-extern shadow-calc-dual-verts function) diff --git a/decompiler/config/jak1_ntsc_black_label/hacks.jsonc b/decompiler/config/jak1_ntsc_black_label/hacks.jsonc index d3e710f0d3..bdf186a273 100644 --- a/decompiler/config/jak1_ntsc_black_label/hacks.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/hacks.jsonc @@ -169,7 +169,6 @@ "generic-tie-dma-to-spad-sync", // shadow-cpu - "shadow-execute", "shadow-add-double-edges", "shadow-add-double-tris", "shadow-add-single-edges", @@ -596,7 +595,24 @@ "draw-large-polygon-ocean", "render-ocean-quad", "ocean-generate-verts", - "ocean-interp-wave" + "ocean-interp-wave", + + // shadow + "shadow-execute", + "shadow-add-double-edges", + "shadow-add-double-tris", + "shadow-add-single-edges", + "shadow-add-facing-single-tris", + "shadow-add-verts", + "shadow-find-double-edges", + "shadow-find-facing-double-tris", + "shadow-find-single-edges", + "shadow-find-facing-single-tris", + "shadow-init-vars", + "shadow-scissor-top", + "shadow-scissor-edges", + "shadow-calc-dual-verts", + "shadow-xform-verts" ], "mips2c_jump_table_functions": { diff --git a/decompiler/config/jak1_ntsc_black_label/stack_structures.jsonc b/decompiler/config/jak1_ntsc_black_label/stack_structures.jsonc index 33a0408d3e..21b5550e2d 100644 --- a/decompiler/config/jak1_ntsc_black_label/stack_structures.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/stack_structures.jsonc @@ -5486,5 +5486,11 @@ "ocean-mid-add-matrices": [[16, "vector"]], + "(method 15 shadow-control)": [ + [16, "collide-tri-result"], + [112, "vector"], + [128, "vector"] + ], + "placeholder-do-not-add-below!": [] } diff --git a/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc b/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc index e4862ada14..f18c79b8fe 100644 --- a/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc @@ -7586,5 +7586,110 @@ [[30, 38], "a2", "dma-packet"] ], + "draw-bones-shadow" : [ + [10, "t0", "terrain-context"], + [[36, 100], "t0", "shadow-dma-packet"], + [[53, 58], "t6", "(inline-array vector)"], + [[64, 71], "a0", "vector"], + [[103, 106], "v1", "dma-packet"] + ], + + "shadow-execute-all" : [ + [108, "gp", "shadow-dcache"], + [113, "gp", "shadow-dcache"], + [118, "gp", "shadow-dcache"], + [123, "gp", "shadow-dcache"], + [[54, 58], "v1", "shadow-dcache"], + [[86, 89], "v1", "dma-packet"] + ], + + "shadow-dma-init": [ + [[25, 29], "t6", "dma-packet"], + [[34,37], "t6", "gs-gif-tag"], + [41, "t4", "(pointer gs-reg)"], + [43, "t4", "(pointer gs-reg)"], + [45, "t4", "(pointer gs-test)"], + [47, "t4", "(pointer gs-reg)"], + [49, "t4", "(pointer gs-alpha)"], + [51, "t4", "(pointer gs-reg)"], + [56, "t4", "(pointer gs-frame)"], + [58, "t4", "(pointer gs-reg)"], + [60, "t4", "(pointer gs-zbuf)"], + [62, "t4", "(pointer gs-reg)"], + [69, "t4", "(pointer gs-xy-offset)"], + [71, "t4", "(pointer gs-reg)"], + [77, "t4", "(pointer gs-tex0)"], + [79, "t4", "(pointer gs-reg)"], + [80, "t4", "(pointer gs-tex1)"], + [82, "t4", "(pointer gs-reg)"], + [83, "t4", "(pointer gs-miptbp)"], + [85, "t4", "(pointer gs-reg)"], + [94, "t4", "(pointer gs-clamp)"], + [101, "t3", "gs-gif-tag"], + [103, "t3", "gs-gif-tag"], + [109, "t3", "(pointer gs-prim)"], + [111, "t3", "(pointer gs-rgbaq)"], + [[120, 123], "t3", "gs-gif-tag"], + [141, "t5", "(pointer gs-xyzf)"], + [154, "t5", "(pointer gs-xyzf)"], + [[165, 168], "a3", "gs-gif-tag"], + [175, "a3", "(pointer gs-test)"], + [177, "a3", "(pointer gs-reg64)"], + [179, "a3", "(pointer gs-zbuf)"], + [181, "a3", "(pointer gs-reg64)"], + [186, "a3", "(pointer gs-frame)"], + [188, "a3", "(pointer gs-reg64)"], + [189, "a3", "(pointer uint64)"], + [191, "a3", "(pointer gs-reg64)"], + [198, "a3", "(pointer gs-test)"], + [200, "a3", "(pointer gs-reg64)"], + [202, "a3", "(pointer gs-zbuf)"], + [204, "a3", "(pointer gs-reg64)"], + [209, "a3", "(pointer gs-frame)"], + [211, "a3", "(pointer gs-reg64)"], + [212, "a3", "(pointer uint64)"], + [214, "a3", "(pointer gs-reg64)"], + [[223, 234], "v1", "(pointer uint64)"] + ], + + "shadow-dma-end": [ + [137, "f2", "int"], + [[27, 32], "t3", "dma-packet"], + [[38, 41], "t3", "gs-gif-tag"], + [45, "t3", "(pointer uint64)"], + [47, "t3", "(pointer gs-reg64)"], + [49, "t3", "(pointer gs-test)"], + [51, "t3", "(pointer gs-reg64)"], + [56, "t3", "(pointer gs-frame)"], + [58, "t3", "(pointer gs-reg64)"], + [59, "t3", "(pointer uint64)"], + [61, "t3", "(pointer gs-reg64)"], + [[68, 73], "t4", "dma-packet"], + [[111, 114], "t4", "gs-gif-tag"], + [115, "t4", "(pointer gs-prim)"], + [[107, 117], "t5", "gs-rgbaq"], + // [[75, 106], "t4", "gs-rgbaq"] + [116, "t4", "(pointer gs-rgbaq)"], + [[121, 124], "t4", "(inline-array gs-gif-tag)"], + [165, "t7", "(pointer gs-xyzf)"], + [184, "t7", "(pointer gs-st)"], + [197, "t7", "(pointer gs-xyzf)"], + [[216, 222], "t2", "(pointer uint64)"], + [[228, 232], "t0", "dma-packet"], + [[238, 241], "t0", "gs-gif-tag"], + [246, "t0", "(pointer gs-test)"], + [248, "t0", "(pointer gs-reg64)"], + [255, "t0", "(pointer gs-xy-offset)"], + [257, "t0", "(pointer gs-reg64)"], + [259, "t0", "(pointer gs-alpha)"], + [261, "t0", "(pointer gs-reg64)"], + [266, "t0", "(pointer gs-frame)"], + [268, "t0", "(pointer gs-reg64)"], + [270, "t0", "(pointer gs-zbuf)"], + [272, "t0", "(pointer gs-reg64)"], + [273, "t0", "(pointer uint64)"], + [275, "t0", "(pointer gs-reg64)"] + ], + "placeholder-do-not-add-below": [] } diff --git a/game/CMakeLists.txt b/game/CMakeLists.txt index fe9775df9a..c8993139c6 100644 --- a/game/CMakeLists.txt +++ b/game/CMakeLists.txt @@ -52,6 +52,7 @@ set(RUNTIME_SOURCE mips2c/functions/ocean.cpp mips2c/functions/ocean_vu0.cpp mips2c/functions/ripple.cpp + mips2c/functions/shadow.cpp mips2c/functions/sky_tng.cpp mips2c/functions/sparticle.cpp mips2c/functions/sparticle_launcher.cpp @@ -108,6 +109,7 @@ set(RUNTIME_SOURCE graphics/opengl_renderer/OpenGLRenderer.cpp graphics/opengl_renderer/Profiler.cpp graphics/opengl_renderer/Shader.cpp + graphics/opengl_renderer/ShadowRenderer.cpp graphics/opengl_renderer/SkyBlendCPU.cpp graphics/opengl_renderer/SkyBlendGPU.cpp graphics/opengl_renderer/SkyRenderer.cpp diff --git a/game/graphics/opengl_renderer/OpenGLRenderer.cpp b/game/graphics/opengl_renderer/OpenGLRenderer.cpp index 41e21037cf..695e64a835 100644 --- a/game/graphics/opengl_renderer/OpenGLRenderer.cpp +++ b/game/graphics/opengl_renderer/OpenGLRenderer.cpp @@ -13,6 +13,7 @@ #include "game/graphics/opengl_renderer/background/Tie3.h" #include "game/graphics/opengl_renderer/MercRenderer.h" #include "game/graphics/opengl_renderer/EyeRenderer.h" +#include "game/graphics/opengl_renderer/ShadowRenderer.h" #include "game/graphics/opengl_renderer/GenericRenderer.h" #include "game/graphics/opengl_renderer/ocean/OceanMidAndFar.h" #include "game/graphics/opengl_renderer/ocean/OceanNear.h" @@ -183,8 +184,8 @@ void OpenGLRenderer::init_bucket_renderers() { BucketId::MERC_AFTER_ALPHA); init_bucket_renderer("common-alpha-generic", BucketCategory::GENERIC_MERC, - BucketId::GENERIC_ALPHA); // 46 - // 47? + BucketId::GENERIC_ALPHA); // 46 + init_bucket_renderer("shadow", BucketCategory::OTHER, BucketId::SHADOW); // 47 //----------------------- // LEVEL 0 pris texture diff --git a/game/graphics/opengl_renderer/ShadowRenderer.cpp b/game/graphics/opengl_renderer/ShadowRenderer.cpp new file mode 100644 index 0000000000..d6c062af2b --- /dev/null +++ b/game/graphics/opengl_renderer/ShadowRenderer.cpp @@ -0,0 +1,16 @@ +#include "ShadowRenderer.h" + +ShadowRenderer::ShadowRenderer(const std::string& name, BucketId my_id) + : BucketRenderer(name, my_id), m_direct(name, my_id, 0x4000) {} + +void ShadowRenderer::draw_debug_window() { + m_direct.draw_debug_window(); +} + +void ShadowRenderer::render(DmaFollower& dma, + SharedRenderState* render_state, + ScopedProfilerNode& /*prof*/) { + while (dma.current_tag_offset() != render_state->next_bucket) { + dma.read_and_advance(); + } +} \ No newline at end of file diff --git a/game/graphics/opengl_renderer/ShadowRenderer.h b/game/graphics/opengl_renderer/ShadowRenderer.h new file mode 100644 index 0000000000..2463bc4d64 --- /dev/null +++ b/game/graphics/opengl_renderer/ShadowRenderer.h @@ -0,0 +1,14 @@ +#pragma once + +#include "game/graphics/opengl_renderer/BucketRenderer.h" +#include "game/graphics/opengl_renderer/DirectRenderer.h" + +class ShadowRenderer : public BucketRenderer { + public: + ShadowRenderer(const std::string& name, BucketId my_id); + void render(DmaFollower& dma, SharedRenderState* render_state, ScopedProfilerNode& prof) override; + void draw_debug_window() override; + + private: + DirectRenderer m_direct; +}; diff --git a/game/graphics/opengl_renderer/buckets.h b/game/graphics/opengl_renderer/buckets.h index 2e054a86ac..b12df1f650 100644 --- a/game/graphics/opengl_renderer/buckets.h +++ b/game/graphics/opengl_renderer/buckets.h @@ -50,7 +50,7 @@ enum class BucketId { // 44 MERC_AFTER_ALPHA = 45, GENERIC_ALPHA = 46, - // 47 + SHADOW = 47, PRIS_TEX_LEVEL0 = 48, MERC_PRIS_LEVEL0 = 49, GENERIC_PRIS_LEVEL0 = 50, diff --git a/game/mips2c/functions/shadow.cpp b/game/mips2c/functions/shadow.cpp new file mode 100644 index 0000000000..4d470d3cbd --- /dev/null +++ b/game/mips2c/functions/shadow.cpp @@ -0,0 +1,2576 @@ +//--------------------------MIPS2C--------------------- +#include "game/mips2c/mips2c_private.h" +#include "game/kernel/kscheme.h" +namespace Mips2C { +// 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 + 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, c->Q); 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); + // 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); + // 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 + 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, c->Q); + // 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); + // 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()); + // 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 + 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, c->Q); + // 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); + // 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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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 + // 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) + // 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 + // 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) + // 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 + // 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) + // 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 + // 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) + // 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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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) + 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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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" +#include "game/kernel/kscheme.h" +namespace Mips2C { +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 diff --git a/game/mips2c/mips2c_private.h b/game/mips2c/mips2c_private.h index 95b65196cc..9ac8860f46 100644 --- a/game/mips2c/mips2c_private.h +++ b/game/mips2c/mips2c_private.h @@ -652,6 +652,13 @@ struct ExecutionContext { } } + void psllh(int dest, int src, int sa) { + auto s = gpr_src(src); + for (int i = 0; i < 8; i++) { + gprs[dest].ds16[i] = s.ds16[i] << (sa & 0x1f); + } + } + void prot3w(int dst, int src) { auto s = gpr_src(src); gprs[dst].du32[0] = s.du32[1]; @@ -949,6 +956,10 @@ struct ExecutionContext { gprs[dst].du64[0] = (gpr_src(src0).du64[0] < gpr_src(src1).du64[0]) ? 1 : 0; } + void sltiu(int dst, int src, u64 imm) { + gprs[dst].du64[0] = (gpr_src(src).du64[0] < imm) ? 1 : 0; + } + void sll(int dst, int src, int sa) { u32 value = gpr_src(src).du32[0] << sa; s32 value_signed = value; diff --git a/game/mips2c/mips2c_table.cpp b/game/mips2c/mips2c_table.cpp index 4f14491227..9bacb966d6 100644 --- a/game/mips2c/mips2c_table.cpp +++ b/game/mips2c/mips2c_table.cpp @@ -275,6 +275,51 @@ extern void link(); namespace ocean_generate_verts { extern void link(); } +namespace shadow_execute { +extern void link(); +} +namespace shadow_add_double_edges { +extern void link(); +} +namespace shadow_add_double_tris { +extern void link(); +} +namespace shadow_add_single_edges { +extern void link(); +} +namespace shadow_add_facing_single_tris { +extern void link(); +} +namespace shadow_add_verts { +extern void link(); +} +namespace shadow_find_double_edges { +extern void link(); +} +namespace shadow_find_facing_double_tris { +extern void link(); +} +namespace shadow_find_single_edges { +extern void link(); +} +namespace shadow_find_facing_single_tris { +extern void link(); +} +namespace shadow_init_vars { +extern void link(); +} +namespace shadow_scissor_top { +extern void link(); +} +namespace shadow_scissor_edges { +extern void link(); +} +namespace shadow_calc_dual_verts { +extern void link(); +} +namespace shadow_xform_verts { +extern void link(); +} LinkedFunctionTable gLinkedFunctionTable; Rng gRng; std::unordered_map> gMips2CLinkCallbacks = { @@ -321,7 +366,14 @@ std::unordered_map> gMips2CLinkCallbacks = {ripple_execute_init::link, ripple_create_wave_table::link, ripple_apply_wave_table::link, ripple_matrix_scale::link}}, {"ocean", {init_ocean_far_regs::link, render_ocean_quad::link, draw_large_polygon_ocean::link}}, - {"ocean-vu0", {ocean_interp_wave::link, ocean_generate_verts::link}}}; + {"ocean-vu0", {ocean_interp_wave::link, ocean_generate_verts::link}}, + {"shadow-cpu", + {shadow_execute::link, shadow_add_double_edges::link, shadow_add_double_tris::link, + shadow_add_single_edges::link, shadow_add_facing_single_tris::link, shadow_add_verts::link, + shadow_find_double_edges::link, shadow_find_facing_double_tris::link, + shadow_find_single_edges::link, shadow_find_facing_single_tris::link, shadow_init_vars::link, + shadow_scissor_top::link, shadow_scissor_edges::link, shadow_calc_dual_verts::link, + shadow_xform_verts::link}}}; void LinkedFunctionTable::reg(const std::string& name, u64 (*exec)(void*), u32 stack_size) { const auto& it = m_executes.insert({name, {exec, Ptr()}}); diff --git a/goal_src/engine/anim/bones.gc b/goal_src/engine/anim/bones.gc index 714f6e1aad..8418441690 100644 --- a/goal_src/engine/anim/bones.gc +++ b/goal_src/engine/anim/bones.gc @@ -380,8 +380,8 @@ (format #t "Too many shadow-queues!!~%") ) (let ((v1-13 (-> gp-1 run (-> gp-1 cur-run)))) - (set! (-> v1-13 first) (the-as uint 0)) - (set! (-> v1-13 next) (the-as uint 0)) + (set! (-> v1-13 first) (the-as dma-packet 0)) + (set! (-> v1-13 next) (the-as (pointer dma-packet) 0)) ) ) 0 @@ -660,7 +660,109 @@ ) ) -;; TODO draw-bones-shadow +(defun draw-bones-shadow ((arg0 draw-control) (arg1 pointer) (arg2 pointer)) + ;; (local-vars (ra-0 int)) + + ;; the dma packet we'll use for shadow in the end. + (let* ((v1-0 (the-as dma-packet (&+ arg2 0))) + ;; the shadow to draw + (t1-0 (-> arg0 shadow)) + ;; the shadow run to add to + (a3-4 (-> *shadow-queue* run (-> *shadow-queue* cur-run))) + ;; the dma data to add to + (a2-1 (&+ arg2 16)) + ;; the distance of the thing we're drawing + (t4-0 (-> (scratchpad-object terrain-context) work foreground bone-mem work distance w)) + ;; the shadow packet we'll build here + (t0-2 (the-as shadow-dma-packet a2-1)) + (t2-0 (-> t1-0 header num-joints)) + (t3-0 (-> a3-4 next)) + (t5-2 (if (-> arg0 shadow-ctrl) + (-> arg0 shadow-ctrl settings) + *default-shadow-settings* + ) + ) + (t6-0 (-> t5-2 flags)) + ) + (-> arg0 cur-lod) + (when (zero? (logand t6-0 2)) + (if (< (-> t5-2 fade-dist) t4-0) + (set! t6-0 (logior t6-0 32)) + ) + ) + (cond + ((zero? (logand t6-0 32)) + (let ((t2-1 (* t2-0 8)) + (t4-4 (-> t1-0 total-size)) + ) + 0 + (set! (-> t0-2 tag dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt))) + (set! (-> t0-2 tag vif0) (new 'static 'vif-tag)) + (set! (-> t0-2 tag vif1) (new 'static 'vif-tag)) + (if (nonzero? t3-0) + (set! (-> t3-0 0) (the-as dma-packet t0-2)) + ) + (if (zero? (-> a3-4 first)) + (set! (-> a3-4 first) (the-as dma-packet t0-2)) + ) + (let ((t3-5 (&-> t0-2 tag vif1))) + (let ((t6-4 (the-as (inline-array vector) (-> t0-2 settings))) + (t7-3 (-> t5-2 center quad)) + (t8-0 (-> t5-2 shadow-dir quad)) + (t9-0 (-> t5-2 bot-plane quad)) + (ra-0 (-> t5-2 top-plane quad)) + ) + ;; (.lq ra-0 48 t5-2) + (let ((t5-3 (-> t5-2 fade-vec quad))) + (set! (-> t6-4 0 quad) t7-3) + (set! (-> t6-4 1 quad) t8-0) + (set! (-> t6-4 2 quad) t9-0) + (set! (-> t6-4 3 quad) ra-0) + (set! (-> t6-4 4 quad) t5-3) + ) + ) + (let ((a0-3 + (the-as + vector + (+ (the-as uint (-> arg0 skeleton bones 0 transform vector 3)) + (* (the-as uint 96) (-> arg0 shadow-joint-index)) + ) + ) + ) + ) + (set! (-> t0-2 settings center x) (-> a0-3 x)) + (set! (-> t0-2 settings center y) (-> a0-3 y)) + (set! (-> t0-2 settings center z) (-> a0-3 z)) + ) + (set! (-> t0-2 geo-ref dma) + (new 'static 'dma-tag :id (dma-tag-id ref) :addr (the-as int (&-> t1-0 total-size)) :qwc t4-4) + ) + (set! (-> t0-2 geo-ref vif0) (new 'static 'vif-tag)) + (set! (-> t0-2 geo-ref vif1) (new 'static 'vif-tag)) + (set! (-> t0-2 mtx-ref dma) + (new 'static 'dma-tag :id (dma-tag-id ref) :addr (the-as int (&+ arg1 256)) :qwc t2-1) + ) + (set! (-> t0-2 mtx-ref vif0) (new 'static 'vif-tag)) + (set! (-> t0-2 mtx-ref vif1) (new 'static 'vif-tag)) + (set! (-> t0-2 end-tag dma) (new 'static 'dma-tag :id (dma-tag-id end))) + (set! (-> t0-2 end-tag vif0) (new 'static 'vif-tag)) + (set! (-> t0-2 end-tag vif1) (new 'static 'vif-tag)) + (let ((v0-0 (&+ a2-1 144))) + (set! (-> a3-4 next) (the-as (pointer dma-packet) t3-5)) + (set! (-> v1-0 dma) (new 'static 'dma-tag :id (dma-tag-id next) :addr (the-as int v0-0))) + (set! (-> v1-0 vif0) (new 'static 'vif-tag)) + (set! (-> v1-0 vif1) (new 'static 'vif-tag)) + v0-0 + ) + ) + ) + ) + (else + (the-as pointer v1-0) + ) + ) + ) + ) ;(def-mips2c draw-bones-generic-merc (function draw-control pointer pointer int pointer)) (defun draw-bones-generic-merc ((arg0 draw-control) (arg1 pointer) (arg2 pointer) (arg3 int)) @@ -1198,12 +1300,12 @@ ;; draw shadow! ;; TODO - ; (when (-> arg0 shadow) - ; (when #t - ; (set! s2-0 (draw-bones-shadow arg0 matrix-data s2-0)) - ; (set! (-> dma-buf base) (the-as pointer s2-0)) - ; ) - ; ) + (when (-> arg0 shadow) + (when #t + (set! s2-0 (draw-bones-shadow arg0 (the pointer matrix-data) (the pointer s2-0))) + (set! (-> dma-buf base) (the-as pointer s2-0)) + ) + ) ;; draw merc! diff --git a/goal_src/engine/dma/dma-h.gc b/goal_src/engine/dma/dma-h.gc index 59d8f1ec7a..f8af1ab695 100644 --- a/goal_src/engine/dma/dma-h.gc +++ b/goal_src/engine/dma/dma-h.gc @@ -259,6 +259,8 @@ (bucket-45 45) ;; merc (bucket-46 46) + + (shadow 47) (pris-tex0 48) (bucket-49 49) ;; merc diff --git a/goal_src/engine/draw/drawable.gc b/goal_src/engine/draw/drawable.gc index 02928c07e7..2da7fe1cb1 100644 --- a/goal_src/engine/draw/drawable.gc +++ b/goal_src/engine/draw/drawable.gc @@ -1140,7 +1140,7 @@ (let ((gp-9 (-> *display* frames (-> *display* on-screen) frame global-buf))) (bones-mtx-calc-execute) ;; skinning matrix calculation (generic-merc-execute-all gp-9) ;; mercneric conversion. - ;;(shadow-execute-all gp-9 *shadow-queue*) + (shadow-execute-all gp-9 *shadow-queue*) (update-eyes) ) diff --git a/goal_src/engine/game/task/process-taskable.gc b/goal_src/engine/game/task/process-taskable.gc index 52e8df301a..3bab3a3c36 100644 --- a/goal_src/engine/game/task/process-taskable.gc +++ b/goal_src/engine/game/task/process-taskable.gc @@ -1435,8 +1435,8 @@ (let ((gp-0 (-> obj draw shadow-ctrl))) (cond ((and (-> obj draw shadow) (zero? (-> obj draw cur-lod)) (logtest? (-> obj draw status) (draw-status was-drawn))) - ;(dummy-15 gp-0 (-> obj draw origin) -4096.0 4096.0 32768.0) - (dummy-14 gp-0) + (collide-to-find-planes gp-0 (-> obj draw origin) -4096.0 4096.0 32768.0) + (update-direction-from-time-of-day gp-0) ) (else (let ((v1-10 gp-0)) diff --git a/goal_src/engine/gfx/shadow/shadow-cpu-h.gc b/goal_src/engine/gfx/shadow/shadow-cpu-h.gc index 34dc252c5b..07a797cfab 100644 --- a/goal_src/engine/gfx/shadow/shadow-cpu-h.gc +++ b/goal_src/engine/gfx/shadow/shadow-cpu-h.gc @@ -16,6 +16,7 @@ (fade-start float :offset-assert 68) (dummy-2 int32 :offset-assert 72) (dummy-3 int32 :offset-assert 76) + (fade-vec vector :inline :offset 64) ;; added ) :method-count-assert 9 :size-assert #x50 @@ -35,8 +36,8 @@ (set-top-plane-offset (shadow-control float) int 11) (set-bottom-plane-offset (shadow-control float) int 12) (dummy-13 (_type_) none 13) - (dummy-14 (_type_) none 14) - (dummy-15 (_type_ vector float float float) none 15) + (update-direction-from-time-of-day (_type_) none 14) + (collide-to-find-planes (_type_ vector float float float) none 15) ) ) @@ -74,9 +75,9 @@ (texscale vector :inline :offset-assert 16) (clrs vector 2 :inline :offset-assert 32) (dma-unpack-template dma-packet :inline :offset-assert 64) - (dma-cnt uint64 :offset-assert 80) - (vif-nop uint32 :offset-assert 88) - (vif-unpack-v4-8 uint32 :offset-assert 92) + (dma-cnt dma-tag :offset-assert 80) + (vif-nop vif-tag :offset-assert 88) + (vif-unpack-v4-8 vif-tag :offset-assert 92) (pdc basic :offset-assert 96) (dist float :offset-assert 100) (oddeven uint8 :offset-assert 104) @@ -97,8 +98,8 @@ ) (deftype shadow-run (structure) - ((first uint32 :offset-assert 0) - (next uint32 :offset-assert 4) + ((first dma-packet :offset-assert 0) + (next (pointer dma-packet) :offset-assert 4) ) :allow-misaligned :method-count-assert 9 diff --git a/goal_src/engine/gfx/shadow/shadow-cpu.gc b/goal_src/engine/gfx/shadow/shadow-cpu.gc index 17a7c282b9..a229fbc39e 100644 --- a/goal_src/engine/gfx/shadow/shadow-cpu.gc +++ b/goal_src/engine/gfx/shadow/shadow-cpu.gc @@ -5,13 +5,577 @@ ;; name in dgo: shadow-cpu ;; dgos: GAME, ENGINE -;; TODO - for video -(define-extern *shadow-data* shadow-data) +(defmethod asize-of shadow-geo ((obj shadow-geo)) + (the-as int (-> obj total-size)) + ) -;; todo -(define *shadow-data* (new 'static 'shadow-data)) +(defmethod mem-usage shadow-geo ((obj shadow-geo) (arg0 memory-usage-block) (arg1 int)) + (set! (-> arg0 length) (max 108 (-> arg0 length))) + (set! (-> arg0 data 107 name) "shadow-geo") + (+! (-> arg0 data 107 count) 1) + (let ((v1-5 (-> obj total-size))) + (+! (-> arg0 data 107 used) v1-5) + (+! (-> arg0 data 107 total) (logand -16 (+ v1-5 15))) + ) + obj + ) -(defmethod dummy-14 shadow-control ((obj shadow-control)) +(define *shadow-data* (new 'static 'shadow-data + :texoffset (new 'static 'vector :x 256.5 :y 112.5) + :texscale + (new 'static 'vector :x 0.001953125 :y 0.00390625) + :clrs + (new 'static 'inline-array vector 2 + (new 'static 'vector :x (the-as float #x80) :w (the-as float #x82)) + (new 'static 'vector :y (the-as float #x80) :w (the-as float #x7f)) + ) + :dma-unpack-template + (new 'static 'dma-packet + :dma + (new 'static 'dma-tag :id (dma-tag-id cnt)) + :vif0 + (new 'static 'vif-tag :cmd (vif-cmd flusha) :msk #x1) + :vif1 + (new 'static 'vif-tag :cmd (vif-cmd unpack-v4-32)) + ) + :dma-cnt + (new 'static 'dma-tag :id (dma-tag-id cnt)) + :vif-unpack-v4-8 + (new 'static 'vif-tag :cmd (vif-cmd unpack-v4-8)) + ) + ) + +(defun shadow-dma-init ((arg0 dma-buffer)) + (let* ((v1-0 *display*) + (a1-2 (-> v1-0 frames (-> v1-0 on-screen) draw frame1 fbp)) + ) + (* a1-2 32) + (let ((t3-0 512) + (t2-0 (-> *video-parms* screen-sy)) + (a2-0 1792) + (a3-0 (-> *video-parms* screen-miny)) + ) + 2304 + (let ((t0-0 (-> *video-parms* screen-maxy)) + (t1-0 (/ t3-0 32)) + (t5-0 (* a3-0 16)) + (v1-11 (-> arg0 base)) + ) + (let* ((t4-0 arg0) + (t6-0 (the-as object (-> t4-0 base))) + ) + (set! (-> (the-as dma-packet t6-0) dma) (new 'static 'dma-tag :id (dma-tag-id cnt))) + (set! (-> (the-as dma-packet t6-0) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet t6-0) vif1) (new 'static 'vif-tag :cmd (vif-cmd direct) :msk #x1)) + (set! (-> t4-0 base) (&+ (the-as pointer t6-0) 16)) + ) + (let* ((t4-1 arg0) + (t6-2 (the-as object (-> t4-1 base))) + ) + (set! (-> (the-as gs-gif-tag t6-2) tag) (new 'static 'gif-tag64 :nloop #xa :eop #x1 :nreg #x1)) + (set! (-> (the-as gs-gif-tag t6-2) regs) (new 'static 'gif-tag-regs :regs0 (gif-reg-id a+d))) + (set! (-> t4-1 base) (&+ (the-as pointer t6-2) 16)) + ) + (let ((t4-2 (-> arg0 base))) + (set! (-> (the-as (pointer gs-reg) t4-2) 8) (gs-reg texflush)) + (set! (-> (the-as (pointer gs-reg) t4-2) 24) (gs-reg test-1)) + (set! (-> (the-as (pointer gs-test) t4-2) 2) + (new 'static 'gs-test :ate #x1 :atst (gs-atest always) :zte #x1 :ztst (gs-ztest always)) + ) + (set! (-> (the-as (pointer gs-reg) t4-2) 40) (gs-reg alpha-1)) + (set! (-> (the-as (pointer gs-alpha) t4-2) 4) (new 'static 'gs-alpha :b #x1 :d #x1)) + (set! (-> (the-as (pointer gs-reg) t4-2) 56) (gs-reg frame-1)) + (set! (-> (the-as (pointer gs-frame) t4-2) 6) (new 'static 'gs-frame :fbw #x8 :fbmsk #xffffff :fbp a1-2)) + (set! (-> (the-as (pointer gs-reg) t4-2) 72) (gs-reg zbuf-1)) + (set! (-> (the-as (pointer gs-zbuf) t4-2) 8) (new 'static 'gs-zbuf :zbp #x1c0 :psm (gs-psm ct24) :zmsk #x1)) + (set! (-> (the-as (pointer gs-reg) t4-2) 88) (gs-reg xyoffset-1)) + (set! (-> (the-as (pointer gs-xy-offset) t4-2) 10) (new 'static 'gs-xy-offset :ofx (* a2-0 16) :ofy t5-0)) + (set! (-> (the-as (pointer gs-reg) t4-2) 104) (gs-reg tex0-1)) + (set! (-> (the-as (pointer gs-tex0) t4-2) 12) + (new 'static 'gs-tex0 :tbw #x8 :tw #x9 :th #x8 :tcc #x1 :tbp0 (* a1-2 32)) + ) + (set! (-> (the-as (pointer gs-reg) t4-2) 120) (gs-reg tex1-1)) + (set! (-> (the-as (pointer gs-tex1) t4-2) 14) (new 'static 'gs-tex1)) + (set! (-> (the-as (pointer gs-reg) t4-2) 136) (gs-reg miptbp1-1)) + (set! (-> (the-as (pointer gs-miptbp) t4-2) 16) (new 'static 'gs-miptbp)) + (set! (-> (the-as (pointer gs-reg) t4-2) 152) (gs-reg clamp-1)) + (set! (-> (the-as (pointer gs-clamp) t4-2) 18) + (new 'static 'gs-clamp + :wms (gs-tex-wrap-mode region-clamp) + :wmt (gs-tex-wrap-mode region-clamp) + :maxv (+ t2-0 -1) + :maxu (+ t3-0 -1) + ) + ) + ) + (&+! (-> arg0 base) 160) + (let* ((t2-7 arg0) + (t3-5 (the-as object (-> t2-7 base))) + ) + (set! (-> (the-as gs-gif-tag t3-5) tag) + (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :flg (gif-flag reg-list) :nreg #x2) + ) + (set! (-> (the-as gs-gif-tag t3-5) regs) (new 'static 'gif-tag-regs :regs1 (gif-reg-id rgbaq))) + (set! (-> t2-7 base) (&+ (the-as pointer t3-5) 16)) + ) + (let* ((t2-8 arg0) + (t3-7 (-> t2-8 base)) + ) + (set! (-> (the-as (pointer gs-prim) t3-7) 0) (new 'static 'gs-prim :prim (gs-prim-type sprite))) + (set! (-> (the-as (pointer gs-rgbaq) t3-7) 1) (new 'static 'gs-rgbaq :a #x60)) + (set! (-> t2-8 base) (&+ t3-7 16)) + ) + (let* ((t2-9 arg0) + (t3-9 (the-as object (-> t2-9 base))) + ) + (set! (-> (the-as gs-gif-tag t3-9) tag) + (new 'static 'gif-tag64 :eop #x1 :flg (gif-flag reg-list) :nreg #x2 :nloop t1-0) + ) + (set! (-> (the-as gs-gif-tag t3-9) regs) + (new 'static 'gif-tag-regs :regs0 (gif-reg-id xyz2) :regs1 (gif-reg-id xyz2)) + ) + (set! (-> t2-9 base) (&+ (the-as pointer t3-9) 16)) + ) + (let ((t2-10 0)) + (dotimes (t3-11 t1-0) + (let* ((t4-10 arg0) + (t5-12 (-> t4-10 base)) + ) + (set! (-> (the-as (pointer gs-xyzf) t5-12) 0) + (new 'static 'gs-xyzf :z #x1ffff :y (* a3-0 16) :x (* (+ a2-0 t2-10) 16)) + ) + (set! (-> (the-as (pointer gs-xyzf) t5-12) 1) + (new 'static 'gs-xyzf :z #x1ffff :y (* t0-0 16) :x (* (+ t2-10 32 a2-0) 16)) + ) + (set! (-> t4-10 base) (&+ t5-12 16)) + ) + (+! t2-10 32) + ) + ) + (let* ((a2-3 arg0) + (a3-1 (the-as object (-> a2-3 base))) + ) + (set! (-> (the-as gs-gif-tag a3-1) tag) (new 'static 'gif-tag64 :nloop #x4 :eop #x1 :nreg #x1)) + (set! (-> (the-as gs-gif-tag a3-1) regs) (new 'static 'gif-tag-regs :regs0 (gif-reg-id a+d))) + (set! (-> a2-3 base) (&+ (the-as pointer a3-1) 16)) + ) + (cond + (*shadow-debug* + (let* ((a2-5 arg0) + (a3-3 (-> a2-5 base)) + ) + (set! (-> (the-as (pointer gs-test) a3-3) 0) + (new 'static 'gs-test :ate #x1 :atst (gs-atest always) :zte #x1 :ztst (gs-ztest greater-equal)) + ) + (set! (-> (the-as (pointer gs-reg64) a3-3) 1) (gs-reg64 test-1)) + (set! (-> (the-as (pointer gs-zbuf) a3-3) 2) (new 'static 'gs-zbuf :zbp #x1c0 :psm (gs-psm ct24))) + (set! (-> (the-as (pointer gs-reg64) a3-3) 3) (gs-reg64 zbuf-1)) + (set! (-> (the-as (pointer gs-frame) a3-3) 4) (new 'static 'gs-frame :fbw #x8 :fbp a1-2)) + (set! (-> (the-as (pointer gs-reg64) a3-3) 5) (gs-reg64 frame-1)) + (set! (-> (the-as (pointer uint64) a3-3) 6) (the-as uint 0)) + (set! (-> (the-as (pointer gs-reg64) a3-3) 7) (gs-reg64 texflush)) + (set! (-> a2-5 base) (&+ a3-3 64)) + ) + ) + (else + (let* ((a2-6 arg0) + (a3-4 (-> a2-6 base)) + ) + (set! (-> (the-as (pointer gs-test) a3-4) 0) + (new 'static 'gs-test :ate #x1 :atst (gs-atest always) :zte #x1 :ztst (gs-ztest greater-equal)) + ) + (set! (-> (the-as (pointer gs-reg64) a3-4) 1) (gs-reg64 test-1)) + (set! (-> (the-as (pointer gs-zbuf) a3-4) 2) (new 'static 'gs-zbuf :zbp #x1c0 :psm (gs-psm ct24) :zmsk #x1)) + (set! (-> (the-as (pointer gs-reg64) a3-4) 3) (gs-reg64 zbuf-1)) + (set! (-> (the-as (pointer gs-frame) a3-4) 4) (new 'static 'gs-frame :fbw #x8 :fbmsk #xffffff :fbp a1-2)) + (set! (-> (the-as (pointer gs-reg64) a3-4) 5) (gs-reg64 frame-1)) + (set! (-> (the-as (pointer uint64) a3-4) 6) (the-as uint 0)) + (set! (-> (the-as (pointer gs-reg64) a3-4) 7) (gs-reg64 texflush)) + (set! (-> a2-6 base) (&+ a3-4 64)) + ) + ) + ) + (let ((a2-10 (/ (the-as int (+ (- -16 (the-as int v1-11)) (the-as int (-> arg0 base)))) 16))) + (cond + ((nonzero? a2-10) + (logior! (-> (the-as (pointer uint64) v1-11) 0) (shr (shl a2-10 48) 48)) + (logior! (-> (the-as (pointer uint64) v1-11) 1) (shl (shr (shl a2-10 48) 48) 32)) + ) + (else + (set! (-> arg0 base) v1-11) + ) + ) + ) + ) + ) + ) + (none) + ) + +(defun shadow-dma-end ((arg0 dma-buffer)) + (local-vars (t9-2 int) (ra-0 int) (ra-1 int) (ra-2 int)) + (let* ((v1-0 *display*) + (v1-5 (-> v1-0 frames (-> v1-0 on-screen) draw frame1 fbp)) + ) + (* v1-5 32) + (let ((a2-0 512) + (a3-0 (-> *video-parms* screen-sy)) + (a1-5 1792) + (t0-1 (-> *video-parms* screen-miny)) + ) + 2304 + (-> *video-parms* screen-maxy) + (let ((t1-3 (/ a2-0 32)) + (a2-3 (+ (* *oddeven* 8) (* t0-1 16))) + ) + (let* ((t2-1 arg0) + (t3-0 (the-as object (-> t2-1 base))) + ) + (set! (-> (the-as dma-packet t3-0) dma) (new 'static 'dma-tag :qwc #x5 :id (dma-tag-id cnt))) + (set! (-> (the-as dma-packet t3-0) vif0) (new 'static 'vif-tag :cmd (vif-cmd flusha) :msk #x1)) + (set! (-> (the-as dma-packet t3-0) vif1) (new 'static 'vif-tag :imm #x5 :cmd (vif-cmd direct) :msk #x1)) + (set! (-> t2-1 base) (&+ (the-as pointer t3-0) 16)) + ) + (let* ((t2-2 arg0) + (t3-2 (the-as object (-> t2-2 base))) + ) + (set! (-> (the-as gs-gif-tag t3-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x4)) + (set! (-> (the-as gs-gif-tag t3-2) regs) + (new 'static 'gif-tag-regs + :regs0 (gif-reg-id a+d) + :regs1 (gif-reg-id a+d) + :regs2 (gif-reg-id a+d) + :regs3 (gif-reg-id a+d) + :regs4 (gif-reg-id a+d) + :regs5 (gif-reg-id a+d) + :regs6 (gif-reg-id a+d) + :regs7 (gif-reg-id a+d) + :regs8 (gif-reg-id a+d) + :regs9 (gif-reg-id a+d) + :regs10 (gif-reg-id a+d) + :regs11 (gif-reg-id a+d) + :regs12 (gif-reg-id a+d) + :regs13 (gif-reg-id a+d) + :regs14 (gif-reg-id a+d) + :regs15 (gif-reg-id a+d) + ) + ) + (set! (-> t2-2 base) (&+ (the-as pointer t3-2) 16)) + ) + (let* ((t2-3 arg0) + (t3-4 (-> t2-3 base)) + ) + (set! (-> (the-as (pointer uint64) t3-4) 0) (the-as uint 0)) + (set! (-> (the-as (pointer gs-reg64) t3-4) 1) (gs-reg64 texflush)) + (set! (-> (the-as (pointer gs-test) t3-4) 2) + (new 'static 'gs-test :ate #x1 :atst (gs-atest not-equal) :aref #x60 :zte #x1 :ztst (gs-ztest always)) + ) + (set! (-> (the-as (pointer gs-reg64) t3-4) 3) (gs-reg64 test-1)) + (set! (-> (the-as (pointer gs-frame) t3-4) 4) (new 'static 'gs-frame :fbw #x8 :fbp v1-5)) + (set! (-> (the-as (pointer gs-reg64) t3-4) 5) (gs-reg64 frame-1)) + (set! (-> (the-as (pointer uint64) t3-4) 6) (the-as uint 0)) + (set! (-> (the-as (pointer gs-reg64) t3-4) 7) (gs-reg64 texflush)) + (set! (-> t2-3 base) (&+ t3-4 64)) + ) + (let ((t2-4 (-> arg0 base))) + (let* ((t3-6 arg0) + (t4-13 (the-as object (-> t3-6 base))) + ) + (set! (-> (the-as dma-packet t4-13) dma) (new 'static 'dma-tag :id (dma-tag-id cnt))) + (set! (-> (the-as dma-packet t4-13) vif0) (new 'static 'vif-tag :cmd (vif-cmd flusha) :msk #x1)) + (set! (-> (the-as dma-packet t4-13) vif1) (new 'static 'vif-tag :cmd (vif-cmd direct) :msk #x1)) + (set! (-> t3-6 base) (&+ (the-as pointer t4-13) 16)) + ) + (let* ((t4-15 (the-as uint #x3f80000080404040)) + (t3-8 (-> *time-of-day-context* current-shadow-color)) + (t5-14 + (the-as + gs-rgbaq + (logior (logand (logior (logand (logior (logand t4-15 -256) (shr (shl (the int (* 128.0 (-> t3-8 x))) 56) 56)) -65281) + (shr (shl (the int (* 128.0 (-> t3-8 y))) 56) 48) + ) + -16711681 + ) + (shr (shl (the int (* 128.0 (-> t3-8 z))) 56) 40) + ) + ) + ) + (t3-12 arg0) + (t4-21 (the-as object (-> t3-12 base))) + ) + (set! (-> (the-as gs-gif-tag t4-21) tag) + (new 'static 'gif-tag64 :nloop #x1 :flg (gif-flag reg-list) :nreg #x2) + ) + (set! (-> (the-as gs-gif-tag t4-21) regs) (new 'static 'gif-tag-regs :regs1 (gif-reg-id rgbaq))) + (set! (-> (the-as (pointer gs-prim) t4-21) 2) + (new 'static 'gs-prim :prim (gs-prim-type sprite) :tme #x1 :abe #x1) + ) + (set! (-> (the-as (pointer gs-rgbaq) t4-21) 3) t5-14) + (set! (-> (the-as (inline-array gs-gif-tag) t4-21) 2 tag) + (new 'static 'gif-tag64 :eop #x1 :flg (gif-flag reg-list) :nreg #x4 :nloop t1-3) + ) + (set! (-> (the-as (inline-array gs-gif-tag) t4-21) 2 regs) + (new 'static 'gif-tag-regs + :regs0 (gif-reg-id st) + :regs1 (gif-reg-id xyz2) + :regs2 (gif-reg-id st) + :regs3 (gif-reg-id xyz2) + ) + ) + (set! (-> t3-12 base) (&+ (the-as pointer t4-21) 48)) + ) + (let ((t3-13 0) + (t4-23 0) + ) + (dotimes (t5-18 t1-3) + (let ((t8-0 t3-13)) + (+! t3-13 32) + (let* ((t6-5 arg0) + (t7-0 (-> t6-5 base)) + ) + (let ((t9-1 (shl (the-as int (* 0.00390625 (+ 0.5 (the float (the-as int t4-23))))) 32))) + (let ((f0-12 (* 0.001953125 (+ 0.5 (the float t8-0))))) + (.mov ra-0 f0-12) + ) + ;;(.dsll32 ra-1 ra-0 0) + (set! ra-1 (shl ra-0 32)) + ;;(.dsrl32 ra-2 ra-1 0) + (set! ra-2 (shr ra-1 32)) + ;(.or t9-2 t9-1 ra-2) + (set! t9-2 (logior t9-1 ra-2)) + ) + (set! (-> (the-as (pointer int64) t7-0)) t9-2) + (set! (-> (the-as (pointer gs-xyzf) t7-0) 1) + (new 'static 'gs-xyzf :z #x1ffff :y (* (+ t0-1 t4-23) 16) :x (* (+ a1-5 t8-0) 16)) + ) + (set! (-> (the-as (pointer gs-st) t7-0) 2) + (new 'static 'gs-st + :s (* 0.001953125 (+ 0.5 (the float t3-13))) + :t (* 0.00390625 (+ 0.5 (the float a3-0))) + ) + ) + (set! (-> (the-as (pointer gs-xyzf) t7-0) 3) + (new 'static 'gs-xyzf :z #x1ffff :y (* (+ t0-1 a3-0) 16) :x (* (+ a1-5 t3-13) 16)) + ) + (set! (-> t6-5 base) (&+ t7-0 32)) + ) + ) + ) + ) + (let ((t0-5 (/ (the-as int (+ (- -16 (the-as int t2-4)) (the-as int (-> arg0 base)))) 16))) + (cond + ((nonzero? t0-5) + (logior! (-> (the-as (pointer uint64) t2-4)) (shr (shl t0-5 48) 48)) + (logior! (-> (the-as (pointer uint64) t2-4) 1) (shl (shr (shl t0-5 48) 48) 32)) + ) + (else + (set! (-> arg0 base) t2-4) + ) + ) + ) + ) + (let* ((a3-3 arg0) + (t0-11 (the-as object (-> a3-3 base))) + ) + (set! (-> (the-as dma-packet t0-11) dma) (new 'static 'dma-tag :qwc #x7 :id (dma-tag-id cnt))) + (set! (-> (the-as dma-packet t0-11) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet t0-11) vif1) (new 'static 'vif-tag :imm #x7 :cmd (vif-cmd direct) :msk #x1)) + (set! (-> a3-3 base) (&+ (the-as pointer t0-11) 16)) + ) + (let* ((a3-4 arg0) + (t0-13 (the-as object (-> a3-4 base))) + ) + (set! (-> (the-as gs-gif-tag t0-13) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x6)) + (set! (-> (the-as gs-gif-tag t0-13) regs) (new 'static 'gif-tag-regs + :regs0 (gif-reg-id a+d) + :regs1 (gif-reg-id a+d) + :regs2 (gif-reg-id a+d) + :regs3 (gif-reg-id a+d) + :regs4 (gif-reg-id a+d) + :regs5 (gif-reg-id a+d) + :regs6 (gif-reg-id a+d) + :regs7 (gif-reg-id a+d) + :regs8 (gif-reg-id a+d) + :regs9 (gif-reg-id a+d) + :regs10 (gif-reg-id a+d) + :regs11 (gif-reg-id a+d) + :regs12 (gif-reg-id a+d) + :regs13 (gif-reg-id a+d) + :regs14 (gif-reg-id a+d) + :regs15 (gif-reg-id a+d) + ) + ) + (set! (-> a3-4 base) (&+ (the-as pointer t0-13) 16)) + ) + (let* ((a3-5 arg0) + (t0-15 (-> a3-5 base)) + ) + (set! (-> (the-as (pointer gs-test) t0-15) 0) + (new 'static 'gs-test :atst (gs-atest not-equal) :zte #x1 :ztst (gs-ztest greater-equal)) + ) + (set! (-> (the-as (pointer gs-reg64) t0-15) 1) (gs-reg64 test-1)) + (set! (-> (the-as (pointer gs-xy-offset) t0-15) 2) (new 'static 'gs-xy-offset :ofx (* a1-5 16) :ofy a2-3)) + (set! (-> (the-as (pointer gs-reg64) t0-15) 3) (gs-reg64 xyoffset-1)) + (set! (-> (the-as (pointer gs-alpha) t0-15) 4) (new 'static 'gs-alpha :b #x1 :d #x1)) + (set! (-> (the-as (pointer gs-reg64) t0-15) 5) (gs-reg64 alpha-1)) + (set! (-> (the-as (pointer gs-frame) t0-15) 6) (new 'static 'gs-frame :fbw #x8 :fbp v1-5)) + (set! (-> (the-as (pointer gs-reg64) t0-15) 7) (gs-reg64 frame-1)) + (set! (-> (the-as (pointer gs-zbuf) t0-15) 8) (new 'static 'gs-zbuf :zbp #x1c0 :psm (gs-psm ct24))) + (set! (-> (the-as (pointer gs-reg64) t0-15) 9) (gs-reg64 zbuf-1)) + (set! (-> (the-as (pointer uint64) t0-15) 10) (the-as uint 0)) + (set! (-> (the-as (pointer gs-reg64) t0-15) 11) (gs-reg64 texflush)) + (set! (-> a3-5 base) (&+ t0-15 96)) + ) + ) + ) + ) + (none) + ) + +(deftype shadow-stats (structure) + ((num-single-tris uint32 :offset-assert 0) + (num-double-tris uint32 :offset-assert 4) + (num-single-edges uint32 :offset-assert 8) + (num-double-edges uint32 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype shadow-dcache (structure) + ((vtx-table uint32 :offset-assert 0) + (single-edge-table uint32 :offset-assert 4) + (double-edge-table uint32 :offset-assert 8) + (double-tri-table uint32 :offset-assert 12) + (dcache-top uint32 :offset-assert 16) + (num-facing-single-tris uint32 :offset-assert 20) + (num-single-edges uint32 :offset-assert 24) + (num-double-edges uint32 :offset-assert 28) + (single-tri-list uint32 :offset-assert 32) + (single-edge-list uint32 :offset-assert 36) + (double-edge-list uint32 :offset-assert 40) + (ptr-dual-verts uint32 :offset-assert 44) + (stats shadow-stats :inline :offset-assert 48) + (center vector :inline :offset-assert 64) + (plane vector :inline :offset-assert 80) + (top-plane vector :inline :offset-assert 96) + (near-plane vector :inline :offset-assert 112) + (light-dir vector :inline :offset-assert 128) + (vtx-min vector :inline :offset-assert 144) + (data uint8 :dynamic :offset-assert 160) + ) + :method-count-assert 9 + :size-assert #xa0 + :flag-assert #x9000000a0 + ) + +(define shadow-vu0-block (new 'static 'vu-function #|:length 88 :qlength 44|#)) + +(def-mips2c shadow-xform-verts function) +(def-mips2c shadow-execute (function shadow-dma-packet pointer pointer)) + +(defun shadow-vu0-upload () + (#unless PC_PORT + (let ((gp-0 *vu0-dma-list*)) + (let ((v1-0 gp-0)) + (set! (-> v1-0 base) (-> v1-0 data)) + (set! (-> v1-0 end) (&-> v1-0 data-buffer (-> v1-0 allocated-length))) + ) + (dma-buffer-add-vu-function gp-0 shadow-vu0-block 0) + (let* ((v1-1 gp-0) + (a0-5 (-> v1-1 base)) + ) + (set! (-> (the-as (pointer int64) a0-5)) #x70000000) + (s.d! (+ a0-5 8) 0) + (set! (-> v1-1 base) (&+ a0-5 16)) + ) + (.sync.l) + (dma-buffer-send-chain (the-as dma-bank-source #x10008000) gp-0) + ) + ) + 0 + (none) + ) + +(defun shadow-execute-all ((arg0 dma-buffer) (arg1 shadow-queue)) + (if *debug-segment* + (add-frame + (-> *display* frames (-> *display* on-screen) frame profile-bar 0) + 'draw + (new 'static 'rgba :r #x40 :b #x40 :a #x80) + ) + ) + (when (logtest? (vu1-renderer-mask shadow) *vu1-enable-user*) + (when (> (-> arg1 cur-run) 0) + (let ((v1-12 #f)) + (dotimes (a0-6 (the-as int (-> arg1 cur-run))) + (if (nonzero? (-> arg1 run a0-6 first)) + (set! v1-12 #t) + ) + ) + (when v1-12 + (shadow-vu0-upload) + (let* ((s4-0 (-> *display* frames (-> *display* on-screen) frame global-buf)) + (s5-0 (-> s4-0 base)) + ) + (shadow-vu1-init-buffer s4-0) + (flush-cache 0) + (let ((v1-17 (the-as shadow-dcache *gsf-buffer*))) + (set! (-> v1-17 stats num-single-tris) (the-as uint 0)) + (set! (-> v1-17 stats num-double-tris) (the-as uint 0)) + (set! (-> v1-17 stats num-single-edges) (the-as uint 0)) + (set! (-> v1-17 stats num-double-edges) (the-as uint 0)) + ) + 0 + (shadow-dma-init s4-0) + (dotimes (s3-0 (the-as int (-> arg1 cur-run))) + (let ((v1-21 (-> arg1 run s3-0))) + (if (nonzero? (-> v1-21 first)) + (set! (-> s4-0 base) (shadow-execute (the-as shadow-dma-packet (-> v1-21 first)) (-> s4-0 base))) + ) + ) + ) + (shadow-dma-end s4-0) + (let ((a3-0 (-> s4-0 base))) + (let ((v1-25 (the-as object (-> s4-0 base)))) + (set! (-> (the-as dma-packet v1-25) dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> (the-as dma-packet v1-25) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet v1-25) vif1) (new 'static 'vif-tag)) + (set! (-> s4-0 base) (&+ (the-as pointer v1-25) 16)) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + (bucket-id shadow) + s5-0 + (the-as (pointer dma-tag) a3-0) + ) + ) + ) + ) + ) + (when #f + (let ((gp-1 (the-as structure *gsf-buffer*))) + (format *stdcon* "#single tris : ~4d~%" (-> (the-as shadow-dcache gp-1) stats num-single-tris)) + (format *stdcon* "#double tris : ~4d~%" (-> (the-as shadow-dcache gp-1) stats num-double-tris)) + (format *stdcon* "#single edges: ~4d~%" (-> (the-as shadow-dcache gp-1) stats num-single-edges)) + (format *stdcon* "#double edges: ~4d~%" (-> (the-as shadow-dcache gp-1) stats num-double-edges)) + ) + ) + ) + ) + (if *debug-segment* + (add-frame + (-> *display* frames (-> *display* on-screen) frame profile-bar 0) + 'draw + (new 'static 'rgba :r #x40 :g #x42 :b #xe0 :a #x80) + ) + ) + 0 + (none) + ) + +(defmethod update-direction-from-time-of-day shadow-control ((obj shadow-control)) (let ((v1-1 (-> *time-of-day-context* current-shadow))) (set! (-> obj settings shadow-dir x) (-> v1-1 x)) (set! (-> obj settings shadow-dir y) (-> v1-1 y)) @@ -19,4 +583,41 @@ ) 0 (none) + ) + +(defmethod collide-to-find-planes shadow-control ((obj shadow-control) (arg0 vector) (arg1 float) (arg2 float) (arg3 float)) + (with-pp + (let ((s4-0 (new 'stack-no-clear 'collide-tri-result)) + (v1-0 (new 'stack-no-clear 'vector)) + (a2-1 (new 'stack-no-clear 'vector)) + ) + (set! (-> v1-0 quad) (-> arg0 quad)) + (set! (-> v1-0 y) (+ 4096.0 (-> v1-0 y))) + (set-vector! a2-1 0.0 (- arg3) 0.0 1.0) + (cond + ((>= (fill-and-probe-using-line-sphere *collide-cache* v1-0 a2-1 8192.0 (collide-kind background) pp s4-0 1) + 0.0 + ) + (let ((v1-2 obj)) + (set! (-> v1-2 settings flags) (logand -33 (-> v1-2 settings flags))) + ) + 0 + (let ((v1-4 obj)) + (set! (-> v1-4 settings bot-plane w) (- (+ (-> s4-0 intersect y) arg1))) + ) + 0 + (set! (-> obj settings top-plane w) (- (+ (-> s4-0 intersect y) arg2))) + 0 + ) + (else + (let ((v1-7 obj)) + (logior! (-> v1-7 settings flags) 32) + ) + 0 + ) + ) + ) + 0 + (none) + ) ) \ No newline at end of file diff --git a/goal_src/engine/gfx/shadow/shadow-vu1-h.gc b/goal_src/engine/gfx/shadow/shadow-vu1-h.gc index 6027c891f8..7227b72a60 100644 --- a/goal_src/engine/gfx/shadow/shadow-vu1-h.gc +++ b/goal_src/engine/gfx/shadow/shadow-vu1-h.gc @@ -6,3 +6,4 @@ ;; dgos: GAME, ENGINE ;; empty! +(define-extern shadow-vu1-init-buffer (function dma-buffer none)) diff --git a/goal_src/levels/beach/bird-lady.gc b/goal_src/levels/beach/bird-lady.gc index 6c70edb591..34cccae45c 100644 --- a/goal_src/levels/beach/bird-lady.gc +++ b/goal_src/levels/beach/bird-lady.gc @@ -52,7 +52,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/beach/mayor.gc b/goal_src/levels/beach/mayor.gc index cfa01e3021..a17e51e04d 100644 --- a/goal_src/levels/beach/mayor.gc +++ b/goal_src/levels/beach/mayor.gc @@ -49,7 +49,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/beach/sculptor.gc b/goal_src/levels/beach/sculptor.gc index b091cf691a..63346e5474 100644 --- a/goal_src/levels/beach/sculptor.gc +++ b/goal_src/levels/beach/sculptor.gc @@ -59,7 +59,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/citadel/citadel-sages.gc b/goal_src/levels/citadel/citadel-sages.gc index 7cbd5b4c52..7234f0812c 100644 --- a/goal_src/levels/citadel/citadel-sages.gc +++ b/goal_src/levels/citadel/citadel-sages.gc @@ -542,7 +542,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) @@ -659,7 +659,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) @@ -781,7 +781,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/common/nav-enemy.gc b/goal_src/levels/common/nav-enemy.gc index 013dd72959..ca28648a40 100644 --- a/goal_src/levels/common/nav-enemy.gc +++ b/goal_src/levels/common/nav-enemy.gc @@ -83,7 +83,7 @@ (set-collide-offense (-> obj collide-info) 2 (collide-offense touch)) (set! (-> obj nav-enemy-flags) (logand -257 (-> obj nav-enemy-flags))) ) - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) (when *target* (if *target* (look-at-enemy! diff --git a/goal_src/levels/jungle/fisher.gc b/goal_src/levels/jungle/fisher.gc index 2adef4620a..26b49b553f 100644 --- a/goal_src/levels/jungle/fisher.gc +++ b/goal_src/levels/jungle/fisher.gc @@ -852,7 +852,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/snow/snow-ball.gc b/goal_src/levels/snow/snow-ball.gc index f8d0e9c63f..f5f51492b7 100644 --- a/goal_src/levels/snow/snow-ball.gc +++ b/goal_src/levels/snow/snow-ball.gc @@ -128,7 +128,7 @@ :trans (behavior () (set! (-> self root trans quad) (-> (the-as process-drawable (-> self parent 0)) root trans quad)) - (dummy-14 (-> self draw shadow-ctrl)) + (update-direction-from-time-of-day (-> self draw shadow-ctrl)) 0 (none) ) diff --git a/goal_src/levels/village1/assistant.gc b/goal_src/levels/village1/assistant.gc index 1e939d6641..8d0e6e9996 100644 --- a/goal_src/levels/village1/assistant.gc +++ b/goal_src/levels/village1/assistant.gc @@ -53,7 +53,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/village1/explorer.gc b/goal_src/levels/village1/explorer.gc index 8b22d68701..3248780803 100644 --- a/goal_src/levels/village1/explorer.gc +++ b/goal_src/levels/village1/explorer.gc @@ -52,7 +52,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/village1/yakow.gc b/goal_src/levels/village1/yakow.gc index 04ace81c0a..42e0d52c0c 100644 --- a/goal_src/levels/village1/yakow.gc +++ b/goal_src/levels/village1/yakow.gc @@ -232,7 +232,7 @@ yakow-default-event-handler ) (defbehavior yakow-common-post yakow () - (dummy-14 (-> self draw shadow-ctrl)) + (update-direction-from-time-of-day (-> self draw shadow-ctrl)) (if *target* (look-at-enemy! (-> *target* neck) (the-as vector (-> self root-override root-prim prim-core)) #f self) ) diff --git a/goal_src/levels/village2/assistant-village2.gc b/goal_src/levels/village2/assistant-village2.gc index c8832fdff9..621708813e 100644 --- a/goal_src/levels/village2/assistant-village2.gc +++ b/goal_src/levels/village2/assistant-village2.gc @@ -86,7 +86,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/village2/warrior.gc b/goal_src/levels/village2/warrior.gc index 6ab420da5f..8f4520f2db 100644 --- a/goal_src/levels/village2/warrior.gc +++ b/goal_src/levels/village2/warrior.gc @@ -49,7 +49,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/village3/assistant-village3.gc b/goal_src/levels/village3/assistant-village3.gc index 6886794078..ca9196027a 100644 --- a/goal_src/levels/village3/assistant-village3.gc +++ b/goal_src/levels/village3/assistant-village3.gc @@ -49,7 +49,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/village3/miners.gc b/goal_src/levels/village3/miners.gc index 2b784768cb..7dad001dbb 100644 --- a/goal_src/levels/village3/miners.gc +++ b/goal_src/levels/village3/miners.gc @@ -79,7 +79,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) @@ -260,7 +260,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/goal_src/levels/village3/sage-village3.gc b/goal_src/levels/village3/sage-village3.gc index 05d62b3e7e..8569c03c42 100644 --- a/goal_src/levels/village3/sage-village3.gc +++ b/goal_src/levels/village3/sage-village3.gc @@ -327,7 +327,7 @@ (set! (-> a0-8 settings flags) (logand -33 (-> a0-8 settings flags))) ) 0 - (dummy-14 v1-1) + (update-direction-from-time-of-day v1-1) ) (else (logior! (-> v1-1 settings flags) 32) diff --git a/goal_src/levels/village3/village3-obs.gc b/goal_src/levels/village3/village3-obs.gc index d72ad79564..7ba2b6c9ff 100644 --- a/goal_src/levels/village3/village3-obs.gc +++ b/goal_src/levels/village3/village3-obs.gc @@ -320,7 +320,7 @@ :post (behavior () (ja-post) - (dummy-14 (-> self draw shadow-ctrl)) + (update-direction-from-time-of-day (-> self draw shadow-ctrl)) (none) ) ) @@ -419,7 +419,7 @@ (set! (-> v1-34 settings top-plane w) (- 4096.0)) ) 0 - (dummy-14 a0-16) + (update-direction-from-time-of-day a0-16) ) ) (cond diff --git a/test/decompiler/reference/engine/draw/drawable_REF.gc b/test/decompiler/reference/engine/draw/drawable_REF.gc index 03da4c2bc0..a3bca89d85 100644 --- a/test/decompiler/reference/engine/draw/drawable_REF.gc +++ b/test/decompiler/reference/engine/draw/drawable_REF.gc @@ -1157,43 +1157,52 @@ (gp-7 (-> s5-3 base)) ) (let* ((v1-137 s5-3) - (a0-43 (-> v1-137 base)) + (a0-43 (the-as object (-> v1-137 base))) ) - (set! (-> (the-as (pointer int64) a0-43)) #x10000004) - (s.w! (+ a0-43 8) 0) - (let ((a1-23 #x50000004)) - (s.w! (+ a0-43 12) a1-23) - ) - (set! (-> v1-137 base) (&+ a0-43 16)) + (set! (-> (the-as dma-packet a0-43) dma) (new 'static 'dma-tag :qwc #x4 :id (dma-tag-id cnt))) + (set! (-> (the-as dma-packet a0-43) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet a0-43) vif1) (new 'static 'vif-tag :imm #x4 :cmd (vif-cmd direct) :msk #x1)) + (set! (-> v1-137 base) (&+ (the-as pointer a0-43) 16)) ) (let* ((v1-138 s5-3) - (a0-45 (-> v1-138 base)) + (a0-45 (the-as object (-> v1-138 base))) ) - (set! (-> (the-as (pointer uint64) a0-45)) (make-u128 0 (the-as uint #x3000000000008001))) - (let ((a1-26 (the-as uint #xeeeeeeeeeeeeeeee))) - (s.d! (+ a0-45 8) a1-26) - ) - (set! (-> v1-138 base) (&+ a0-45 16)) + (set! (-> (the-as gs-gif-tag a0-45) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x3)) + (set! (-> (the-as gs-gif-tag a0-45) regs) + (new 'static 'gif-tag-regs + :regs0 (gif-reg-id a+d) + :regs1 (gif-reg-id a+d) + :regs2 (gif-reg-id a+d) + :regs3 (gif-reg-id a+d) + :regs4 (gif-reg-id a+d) + :regs5 (gif-reg-id a+d) + :regs6 (gif-reg-id a+d) + :regs7 (gif-reg-id a+d) + :regs8 (gif-reg-id a+d) + :regs9 (gif-reg-id a+d) + :regs10 (gif-reg-id a+d) + :regs11 (gif-reg-id a+d) + :regs12 (gif-reg-id a+d) + :regs13 (gif-reg-id a+d) + :regs14 (gif-reg-id a+d) + :regs15 (gif-reg-id a+d) + ) + ) + (set! (-> v1-138 base) (&+ (the-as pointer a0-45) 16)) ) (let* ((v1-139 s5-3) (a0-47 (-> v1-139 base)) ) - (set! (-> (the-as (pointer int64) a0-47)) #x10001c0) + (set! (-> (the-as (pointer gs-zbuf) a0-47) 0) (new 'static 'gs-zbuf :zbp #x1c0 :psm (gs-psm ct24))) (let ((a1-28 78)) - (s.d! (+ a0-47 8) a1-28) - ) - (let ((a1-29 #x30003)) - (s.d! (+ a0-47 16) a1-29) - ) - (let ((a1-30 71)) - (s.d! (+ a0-47 24) a1-30) - ) - (let ((a1-31 68)) - (s.d! (+ a0-47 32) a1-31) - ) - (let ((a1-32 66)) - (s.d! (+ a0-47 40) a1-32) + (s.d! (+ (the-as (pointer gs-reg) a0-47) 8) a1-28) ) + (set! (-> (the-as (pointer gs-test) a0-47) 2) + (new 'static 'gs-test :ate #x1 :atst (gs-atest always) :zte #x1 :ztst (gs-ztest always)) + ) + (set! (-> (the-as (pointer gs-reg64) a0-47) 3) (gs-reg64 test-1)) + (set! (-> (the-as (pointer gs-alpha) a0-47) 4) (new 'static 'gs-alpha :b #x1 :d #x1)) + (set! (-> (the-as (pointer gs-reg64) a0-47) 5) (gs-reg64 alpha-1)) (set! (-> v1-139 base) (&+ a0-47 48)) ) (screen-gradient @@ -1204,11 +1213,11 @@ (-> *time-of-day-context* erase-color) ) (let ((a3-3 (-> s5-3 base))) - (let ((v1-144 (-> s5-3 base))) - (set! (-> (the-as (pointer int64) v1-144)) #x20000000) - (s.w! (+ v1-144 8) 0) - (s.w! (+ v1-144 12) 0) - (set! (-> s5-3 base) (&+ v1-144 16)) + (let ((v1-144 (the-as object (-> s5-3 base)))) + (set! (-> (the-as dma-packet v1-144) dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> (the-as dma-packet v1-144) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet v1-144) vif1) (new 'static 'vif-tag)) + (set! (-> s5-3 base) (&+ (the-as pointer v1-144) 16)) ) (dma-bucket-insert-tag (-> *display* frames (-> *display* on-screen) frame bucket-group) diff --git a/test/decompiler/reference/engine/game/task/process-taskable_REF.gc b/test/decompiler/reference/engine/game/task/process-taskable_REF.gc index db80899637..b8fa020658 100644 --- a/test/decompiler/reference/engine/game/task/process-taskable_REF.gc +++ b/test/decompiler/reference/engine/game/task/process-taskable_REF.gc @@ -1493,8 +1493,8 @@ (zero? (-> obj draw cur-lod)) (logtest? (-> obj draw status) (draw-status was-drawn)) ) - (dummy-15 gp-0 (-> obj draw origin) -4096.0 4096.0 32768.0) - (dummy-14 gp-0) + (collide-to-find-planes gp-0 (-> obj draw origin) -4096.0 4096.0 32768.0) + (update-direction-from-time-of-day gp-0) ) (else (let ((v1-10 gp-0)) diff --git a/test/decompiler/reference/levels/beach/bird-lady_REF.gc b/test/decompiler/reference/levels/beach/bird-lady_REF.gc index c177886547..01a1526956 100644 --- a/test/decompiler/reference/levels/beach/bird-lady_REF.gc +++ b/test/decompiler/reference/levels/beach/bird-lady_REF.gc @@ -61,7 +61,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/beach/mayor_REF.gc b/test/decompiler/reference/levels/beach/mayor_REF.gc index d57e3654a7..ab46994fea 100644 --- a/test/decompiler/reference/levels/beach/mayor_REF.gc +++ b/test/decompiler/reference/levels/beach/mayor_REF.gc @@ -58,7 +58,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/beach/sculptor_REF.gc b/test/decompiler/reference/levels/beach/sculptor_REF.gc index 451e72e5fd..959c288884 100644 --- a/test/decompiler/reference/levels/beach/sculptor_REF.gc +++ b/test/decompiler/reference/levels/beach/sculptor_REF.gc @@ -69,7 +69,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/citadel/citadel-sages_REF.gc b/test/decompiler/reference/levels/citadel/citadel-sages_REF.gc index 79bdda638d..8c1bb026d3 100644 --- a/test/decompiler/reference/levels/citadel/citadel-sages_REF.gc +++ b/test/decompiler/reference/levels/citadel/citadel-sages_REF.gc @@ -610,7 +610,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) @@ -744,7 +744,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) @@ -883,7 +883,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/common/nav-enemy_REF.gc b/test/decompiler/reference/levels/common/nav-enemy_REF.gc index b0befbb5aa..103119cac7 100644 --- a/test/decompiler/reference/levels/common/nav-enemy_REF.gc +++ b/test/decompiler/reference/levels/common/nav-enemy_REF.gc @@ -88,7 +88,7 @@ (set-collide-offense (-> obj collide-info) 2 (collide-offense touch)) (set! (-> obj nav-enemy-flags) (logand -257 (-> obj nav-enemy-flags))) ) - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) (when *target* (if *target* (look-at-enemy! diff --git a/test/decompiler/reference/levels/jungle/fisher_REF.gc b/test/decompiler/reference/levels/jungle/fisher_REF.gc index 08ebed95ae..6a3f2f2dfe 100644 --- a/test/decompiler/reference/levels/jungle/fisher_REF.gc +++ b/test/decompiler/reference/levels/jungle/fisher_REF.gc @@ -937,7 +937,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/snow/snow-ball_REF.gc b/test/decompiler/reference/levels/snow/snow-ball_REF.gc index 89f4525f1b..fc41b05228 100644 --- a/test/decompiler/reference/levels/snow/snow-ball_REF.gc +++ b/test/decompiler/reference/levels/snow/snow-ball_REF.gc @@ -185,7 +185,7 @@ :trans (behavior () (set! (-> self root trans quad) (-> (the-as process-drawable (-> self parent 0)) root trans quad)) - (dummy-14 (-> self draw shadow-ctrl)) + (update-direction-from-time-of-day (-> self draw shadow-ctrl)) 0 (none) ) diff --git a/test/decompiler/reference/levels/village1/assistant_REF.gc b/test/decompiler/reference/levels/village1/assistant_REF.gc index ec909fed83..bce0ed7dd5 100644 --- a/test/decompiler/reference/levels/village1/assistant_REF.gc +++ b/test/decompiler/reference/levels/village1/assistant_REF.gc @@ -63,7 +63,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/village1/explorer_REF.gc b/test/decompiler/reference/levels/village1/explorer_REF.gc index e8f1c52c4e..84f320a03b 100644 --- a/test/decompiler/reference/levels/village1/explorer_REF.gc +++ b/test/decompiler/reference/levels/village1/explorer_REF.gc @@ -61,7 +61,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/village1/yakow_REF.gc b/test/decompiler/reference/levels/village1/yakow_REF.gc index e3067936be..1405733244 100644 --- a/test/decompiler/reference/levels/village1/yakow_REF.gc +++ b/test/decompiler/reference/levels/village1/yakow_REF.gc @@ -290,7 +290,7 @@ yakow-default-event-handler ;; definition for function yakow-common-post (defbehavior yakow-common-post yakow () - (dummy-14 (-> self draw shadow-ctrl)) + (update-direction-from-time-of-day (-> self draw shadow-ctrl)) (if *target* (look-at-enemy! (-> *target* neck) (the-as vector (-> self root-override root-prim prim-core)) #f self) ) diff --git a/test/decompiler/reference/levels/village2/assistant-village2_REF.gc b/test/decompiler/reference/levels/village2/assistant-village2_REF.gc index 19943ed6e6..46a624c2f9 100644 --- a/test/decompiler/reference/levels/village2/assistant-village2_REF.gc +++ b/test/decompiler/reference/levels/village2/assistant-village2_REF.gc @@ -101,7 +101,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/village2/warrior_REF.gc b/test/decompiler/reference/levels/village2/warrior_REF.gc index d468c361e2..0a2d45c2b0 100644 --- a/test/decompiler/reference/levels/village2/warrior_REF.gc +++ b/test/decompiler/reference/levels/village2/warrior_REF.gc @@ -58,7 +58,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/village3/assistant-village3_REF.gc b/test/decompiler/reference/levels/village3/assistant-village3_REF.gc index 5bb9ef92c7..f0c60cd2dc 100644 --- a/test/decompiler/reference/levels/village3/assistant-village3_REF.gc +++ b/test/decompiler/reference/levels/village3/assistant-village3_REF.gc @@ -58,7 +58,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/village3/miners_REF.gc b/test/decompiler/reference/levels/village3/miners_REF.gc index 6d95f699da..fad1d3b8b3 100644 --- a/test/decompiler/reference/levels/village3/miners_REF.gc +++ b/test/decompiler/reference/levels/village3/miners_REF.gc @@ -87,7 +87,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) @@ -293,7 +293,7 @@ (set! (-> v1-9 settings flags) (logand -33 (-> v1-9 settings flags))) ) 0 - (dummy-14 (-> obj draw shadow-ctrl)) + (update-direction-from-time-of-day (-> obj draw shadow-ctrl)) ) (else (let ((v1-14 (-> obj draw shadow-ctrl))) diff --git a/test/decompiler/reference/levels/village3/sage-village3_REF.gc b/test/decompiler/reference/levels/village3/sage-village3_REF.gc index d73d493744..2d2ad412ec 100644 --- a/test/decompiler/reference/levels/village3/sage-village3_REF.gc +++ b/test/decompiler/reference/levels/village3/sage-village3_REF.gc @@ -347,7 +347,7 @@ (set! (-> a0-8 settings flags) (logand -33 (-> a0-8 settings flags))) ) 0 - (dummy-14 v1-1) + (update-direction-from-time-of-day v1-1) ) (else (logior! (-> v1-1 settings flags) 32)