diff --git a/decompiler/IR2/FormExpressionAnalysis.cpp b/decompiler/IR2/FormExpressionAnalysis.cpp index 345e83543c..1ad5806572 100644 --- a/decompiler/IR2/FormExpressionAnalysis.cpp +++ b/decompiler/IR2/FormExpressionAnalysis.cpp @@ -2143,7 +2143,6 @@ void SetFormFormElement::push_to_stack(const Env& env, FormPool& pool, FormStack // setting a bitfield to zero is wonky. auto bfa = dynamic_cast(m_src->try_as_single_element()); if (bfa) { - fmt::print("setting bfa: {}\n", bfa->to_string(env)); auto zero_set = bfa->get_set_field_0(env.dts->ts); if (zero_set) { auto field_token = DerefToken::make_field_name(zero_set->name()); diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc index 004af9d440..e771293649 100644 --- a/decompiler/config/all-types.gc +++ b/decompiler/config/all-types.gc @@ -7608,7 +7608,7 @@ (artist-step float :offset 28) (master-art-group-name string :offset 32) (master-art-group-index int32 :offset 36) - (blerc-data (pointer uint8) :offset 40) + (blerc-data (pointer uint8) :offset 40) ;; todo, this is probably something else (frames pointer :offset 44) ;; this structure doesn't exist? it's a structure with an array of joint-anim-compressed-hdr starting at offset 12 (data joint-anim-compressed :dynamic :offset-assert 48) ) diff --git a/goal_src/engine/data/art-h.gc b/goal_src/engine/data/art-h.gc index a189ae473d..9988f2d0c5 100644 --- a/goal_src/engine/data/art-h.gc +++ b/goal_src/engine/data/art-h.gc @@ -162,6 +162,7 @@ (artist-step float :offset 28) (master-art-group-name string :offset 32) (master-art-group-index int32 :offset 36) + (blerc-data (pointer uint8) :offset 40) ;; todo, this is probably something else (frames pointer :offset 44) (data joint-anim-compressed :dynamic) ) diff --git a/test/decompiler/reference/engine/data/art-h_REF.gc b/test/decompiler/reference/engine/data/art-h_REF.gc index 93dcf58407..6b3ebf6979 100644 --- a/test/decompiler/reference/engine/data/art-h_REF.gc +++ b/test/decompiler/reference/engine/data/art-h_REF.gc @@ -228,7 +228,7 @@ :size-assert #x14 :flag-assert #xd00000014 (:methods - (dummy-9 (_type_) _type_ 9) + (login (_type_) _type_ 9) (dummy-10 (_type_ string type) art-element 10) (dummy-11 (_type_ string type) int 11) (dummy-12 (_type_) symbol 12) @@ -279,6 +279,7 @@ (artist-step float :offset 28) (master-art-group-name string :offset 32) (master-art-group-index int32 :offset 36) + (blerc-data (pointer uint8) :offset 40) (frames pointer :offset 44) (data joint-anim-compressed :dynamic :offset-assert 48) ) diff --git a/test/decompiler/reference/engine/dma/dma-bucket_REF.gc b/test/decompiler/reference/engine/dma/dma-bucket_REF.gc index ab976d0527..d62694ba01 100644 --- a/test/decompiler/reference/engine/dma/dma-bucket_REF.gc +++ b/test/decompiler/reference/engine/dma/dma-bucket_REF.gc @@ -2,7 +2,7 @@ (in-package goal) ;; definition for function dma-buffer-add-buckets -;; INFO: Return type mismatch pointer vs dma-bucket. +;; INFO: Return type mismatch pointer vs (inline-array dma-bucket). (defun dma-buffer-add-buckets ((dma-buf dma-buffer) (count int)) (let ((v0-0 (-> dma-buf base))) (let ((current-bucket (the-as dma-bucket v0-0))) @@ -22,17 +22,17 @@ ) (set! (-> dma-buf base) (the-as pointer current-bucket)) ) - (the-as dma-bucket v0-0) + (the-as (inline-array dma-bucket) v0-0) ) ) ;; definition for function dma-buffer-patch-buckets -(defun dma-buffer-patch-buckets ((bucket dma-bucket) (count int)) +(defun dma-buffer-patch-buckets ((bucket (inline-array dma-bucket)) (count int)) (when (nonzero? bucket) (dotimes (i count) - (set! (-> bucket last 0 addr) (the-as int (&+ (the-as pointer bucket) 16))) - (set! (-> bucket last) (the-as (pointer dma-tag) 0)) - (set! bucket (the-as dma-bucket (&+ (the-as pointer bucket) 16))) + (set! (-> bucket 0 last 0 addr) (the-as int (the-as pointer (-> bucket 1)))) + (set! (-> bucket 0 last) (the-as (pointer dma-tag) 0)) + (set! bucket (the-as (inline-array dma-bucket) (-> bucket 1))) ) ) bucket @@ -41,12 +41,12 @@ ;; definition for function dma-bucket-insert-tag (defun dma-bucket-insert-tag - ((base dma-bucket) + ((base (inline-array dma-bucket)) (idx bucket-id) (tag-start pointer) (tag-end (pointer dma-tag)) ) - (let ((bucket (the-as dma-bucket (+ (the-as uint base) (* idx 16))))) + (let ((bucket (-> base idx))) (set! (-> (the-as dma-bucket (-> bucket last)) next) (the-as uint tag-start)) (set! (-> bucket last) tag-end) ) diff --git a/test/decompiler/reference/engine/gfx/hw/display-h_REF.gc b/test/decompiler/reference/engine/gfx/hw/display-h_REF.gc index aea4733a27..921c97e646 100644 --- a/test/decompiler/reference/engine/gfx/hw/display-h_REF.gc +++ b/test/decompiler/reference/engine/gfx/hw/display-h_REF.gc @@ -85,14 +85,14 @@ ;; definition of type display-frame (deftype display-frame (basic) - ((calc-buf dma-buffer :offset 8) - (vu1-buf dma-buffer :offset 8) - (debug-buf dma-buffer :offset 36) - (global-buf dma-buffer :offset 40) - (bucket-group dma-bucket :offset 44) - (buffer dma-buffer 11 :offset 4) - (profile-bar profile-bar 2 :offset 48) - (run-time uint64 :offset 56) + ((calc-buf dma-buffer :offset 8) + (vu1-buf dma-buffer :offset 8) + (debug-buf dma-buffer :offset 36) + (global-buf dma-buffer :offset 40) + (bucket-group (inline-array dma-bucket) :offset 44) + (buffer dma-buffer 11 :offset 4) + (profile-bar profile-bar 2 :offset 48) + (run-time uint64 :offset 56) ) :method-count-assert 9 :size-assert #x40 diff --git a/test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc b/test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc index 28a2980c42..e3c01641ed 100644 --- a/test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc +++ b/test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc @@ -81,7 +81,7 @@ :size-assert #x18 :flag-assert #xa00000018 (:methods - (dummy-9 () none 9) + (login-adgifs (_type_) none 9) ) ) @@ -160,10 +160,10 @@ ) ;; definition for function merc-fragment-fp-data -;; INFO: Return type mismatch int vs pointer. +;; INFO: Return type mismatch int vs merc-fp-header. (defun merc-fragment-fp-data ((arg0 merc-fragment)) (the-as - pointer + merc-fp-header (+ (the-as uint arg0) (* (-> arg0 header mm-quadword-fp-off) 16)) ) ) @@ -173,6 +173,7 @@ ((matrix-number uint8 :offset-assert 0) (matrix-dest uint8 :offset-assert 1) ) + :pack-me :method-count-assert 9 :size-assert #x2 :flag-assert #x900000002 @@ -188,11 +189,11 @@ ;; definition of type merc-fragment-control (deftype merc-fragment-control (structure) - ((unsigned-four-count uint8 :offset-assert 0) - (lump-four-count uint8 :offset-assert 1) - (fp-qwc uint8 :offset-assert 2) - (mat-xfer-count uint8 :offset-assert 3) - (mat-dest-data uint8 :dynamic :offset-assert 4) + ((unsigned-four-count uint8 :offset-assert 0) + (lump-four-count uint8 :offset-assert 1) + (fp-qwc uint8 :offset-assert 2) + (mat-xfer-count uint8 :offset-assert 3) + (mat-dest-data merc-mat-dest :inline :dynamic :offset-assert 4) ) :method-count-assert 9 :size-assert #x4 @@ -200,6 +201,7 @@ ) ;; definition for method 3 of type merc-fragment-control +;; INFO: this function exists in multiple non-identical object files (defmethod inspect merc-fragment-control ((obj merc-fragment-control)) (format #t "[~8x] ~A~%" obj 'merc-fragment-control) (format #t "~Tunsigned-four-count: ~D~%" (-> obj unsigned-four-count)) @@ -344,25 +346,26 @@ ;; definition of type merc-effect (deftype merc-effect (structure) - ((frag-geo merc-fragment :offset-assert 0) - (frag-ctrl merc-fragment-control :offset-assert 4) - (blend-data merc-blend-data :offset-assert 8) - (blend-ctrl merc-blend-ctrl :offset-assert 12) - (dummy0 uint8 :offset-assert 16) - (effect-bits uint8 :offset-assert 17) - (frag-count uint16 :offset-assert 18) - (blend-frag-count uint16 :offset-assert 20) - (tri-count uint16 :offset-assert 22) - (dvert-count uint16 :offset-assert 24) - (dummy1 uint8 :offset-assert 26) - (envmap-usage uint8 :offset-assert 27) - (extra-info merc-extra-info :offset-assert 28) + ((frag-geo merc-fragment :offset-assert 0) + (frag-ctrl merc-fragment-control :offset-assert 4) + (blend-data merc-blend-data :offset-assert 8) + (blend-ctrl merc-blend-ctrl :offset-assert 12) + (dummy0 uint8 :offset-assert 16) + (effect-bits uint8 :offset-assert 17) + (frag-count uint16 :offset-assert 18) + (blend-frag-count uint16 :offset-assert 20) + (tri-count uint16 :offset-assert 22) + (dvert-count uint16 :offset-assert 24) + (dummy1 uint8 :offset-assert 26) + (envmap-usage uint8 :offset-assert 27) + (extra-info merc-extra-info :offset-assert 28) + (data uint64 4 :offset 0) ) :method-count-assert 10 :size-assert #x20 :flag-assert #xa00000020 (:methods - (dummy-9 () none 9) + (login-adgifs (_type_) none 9) ) ) @@ -569,6 +572,7 @@ ) ;; definition for method 3 of type merc-ctrl +;; INFO: this function exists in multiple non-identical object files (defmethod inspect merc-ctrl ((obj merc-ctrl)) (format #t "[~8x] ~A~%" obj (-> obj type)) (format #t "~Tname: ~A~%" (-> obj name)) @@ -582,11 +586,11 @@ ;; definition of type merc-vu1-low-mem (deftype merc-vu1-low-mem (structure) - ((tri-strip-gif qword :inline :offset-assert 0) - (ad-gif qword :inline :offset-assert 16) - (hvdf-offset vector :inline :offset-assert 32) - (perspective uint128 4 :offset-assert 48) - (fog vector :inline :offset-assert 112) + ((tri-strip-gif gs-gif-tag :inline :offset-assert 0) + (ad-gif gs-gif-tag :inline :offset-assert 16) + (hvdf-offset vector :inline :offset-assert 32) + (perspective uint128 4 :offset-assert 48) + (fog vector :inline :offset-assert 112) ) :method-count-assert 9 :size-assert #x80 diff --git a/test/decompiler/reference/engine/gfx/merc/merc_REF.gc b/test/decompiler/reference/engine/gfx/merc/merc_REF.gc new file mode 100644 index 0000000000..b98ca7d9b2 --- /dev/null +++ b/test/decompiler/reference/engine/gfx/merc/merc_REF.gc @@ -0,0 +1,758 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *merc-ctrl-header*, type merc-ctrl-header +(define *merc-ctrl-header* (the-as merc-ctrl-header #f)) + +;; definition for method 5 of type merc-fragment +;; INFO: Return type mismatch uint vs int. +(defmethod asize-of merc-fragment ((obj merc-fragment)) + (the-as int (* (-> obj header mm-quadword-size) 16)) + ) + +;; definition for method 9 of type merc-fragment +;; INFO: Return type mismatch merc-fragment vs none. +(defmethod login-adgifs merc-fragment ((obj merc-fragment)) + (let* ((fp-data (merc-fragment-fp-data obj)) + (eye-ctrl + (the-as merc-eye-ctrl (if (nonzero? (-> *merc-ctrl-header* eye-ctrl)) + (-> *merc-ctrl-header* eye-ctrl) + (the-as merc-eye-ctrl #f) + ) + ) + ) + (shader (the-as adgif-shader (&+ fp-data 16))) + ) + (dotimes (s2-0 (the-as int (-> fp-data shader-cnt))) + (cond + ((and eye-ctrl (= (logand -256 (-> shader texture-id)) #x1cf06f00)) + (adgif-shader-login shader) + (let ((eye-tex-block (get-eye-block (-> eye-ctrl eye-slot) 0))) + (set! (-> shader tex0 tbp0) eye-tex-block) + ) + (set! (-> shader tex0 tw) 5) + (set! (-> shader tex0 th) 5) + (set! (-> shader tex0 tcc) 1) + (set! (-> shader tex0 tbw) 1) + (set! (-> shader tex0 psm) 0) + (set! (-> shader tex1 mxl) 0) + (set! + (-> shader clamp) + (new 'static 'gs-clamp + :wms (gs-tex-wrap-mode clamp) + :wmt (gs-tex-wrap-mode clamp) + :maxu #x1f + :maxv #x1f + ) + ) + ) + ((and eye-ctrl (= (logand -256 (-> shader texture-id)) #x1cf07000)) + (adgif-shader-login shader) + (let ((eye-tex-block-2 (get-eye-block (-> eye-ctrl eye-slot) 1))) + (set! (-> shader tex0 tbp0) eye-tex-block-2) + ) + (set! (-> shader tex0 tw) 5) + (set! (-> shader tex0 th) 5) + (set! (-> shader tex0 tcc) 1) + (set! (-> shader tex0 tbw) 1) + (set! (-> shader tex0 psm) 0) + (set! (-> shader tex1 mxl) 0) + (set! + (-> shader clamp) + (new 'static 'gs-clamp + :wms (gs-tex-wrap-mode clamp) + :wmt (gs-tex-wrap-mode clamp) + :maxu #x1f + :maxv #x1f + ) + ) + ) + (else + (let ((tex (adgif-shader-login shader))) + (when tex + (dotimes (seg 3) + (logior! (-> *merc-ctrl-header* masks seg) (-> tex masks seg)) + ) + ) + ) + ) + ) + (&+! shader 80) + ) + ) + (none) + ) + +;; definition for method 5 of type merc-fragment-control +;; INFO: Return type mismatch uint vs int. +(defmethod asize-of merc-fragment-control ((obj merc-fragment-control)) + (the-as int (+ (* (-> obj mat-xfer-count) 2) 4)) + ) + +;; definition for method 3 of type merc-fragment-control +;; INFO: this function exists in multiple non-identical object files +(defmethod inspect merc-fragment-control ((obj merc-fragment-control)) + (format #t "[~8x] ~A~%" obj 'merc-fragment-control) + (format #t "~Tunsigned-four-count: ~D~%" (-> obj unsigned-four-count)) + (format #t "~Tlump-four-count: ~D~%" (-> obj lump-four-count)) + (format #t "~Tfp-qwc: ~D~%" (-> obj fp-qwc)) + (format #t "~Tmat-xfer-count: ~D~%" (-> obj mat-xfer-count)) + (dotimes (s5-0 (the-as int (-> obj mat-xfer-count))) + (format #t "~Tmat-dest-data[~d]:~%" s5-0) + (format + #t + "~T~Tmatrix-number: ~D~%" + (-> obj mat-dest-data s5-0 matrix-number) + ) + (format #t "~T~Tmatrix-dest: ~D~%" (-> obj mat-dest-data s5-0 matrix-dest)) + ) + obj + ) + +;; definition for method 9 of type merc-effect +;; INFO: Return type mismatch merc-effect vs none. +(defmethod login-adgifs merc-effect ((obj merc-effect)) + (let ((data (-> obj extra-info))) + (when (nonzero? data) + (when (nonzero? (-> data shader-offset)) + (let + ((tex + (adgif-shader-login + (the-as + adgif-shader + (+ (the-as uint data) (* (-> data shader-offset) 16)) + ) + ) + ) + ) + (when tex + (dotimes (seg 3) + (logior! (-> *merc-ctrl-header* masks seg) (-> tex masks seg)) + ) + ) + ) + ) + ) + ) + (let ((ctrl (-> obj frag-ctrl)) + (geo (-> obj frag-geo)) + ) + (dotimes (frag-idx (the-as int (-> obj frag-count))) + (let ((ctrl-size (asize-of ctrl))) + (let ((geo-size (asize-of geo))) + (login-adgifs geo) + (set! geo (the-as merc-fragment (&+ (the-as pointer geo) geo-size))) + ) + (set! + ctrl + (the-as merc-fragment-control (&+ (the-as pointer ctrl) ctrl-size)) + ) + ) + ) + ) + (none) + ) + +;; definition for method 3 of type merc-ctrl +;; INFO: this function exists in multiple non-identical object files +(defmethod inspect merc-ctrl ((obj merc-ctrl)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tname: ~A~%" (-> obj name)) + (format #t "~Tlength: ~D~%" (-> obj length)) + (format #t "~Tnum-joints: ~D~%" (-> obj num-joints)) + (format #t "~Textra: ~A~%" (-> obj extra)) + (inspect (-> obj header)) + (dotimes (s5-0 (the-as int (-> obj header effect-count))) + (inspect (-> obj effect s5-0)) + ) + obj + ) + +;; definition for method 8 of type merc-ctrl +(defmethod + mem-usage + merc-ctrl + ((obj merc-ctrl) (arg0 memory-usage-block) (arg1 int)) + (if (-> obj extra) + (mem-usage (-> obj extra) arg0 arg1) + ) + (let ((ctrl-mem (+ 32 80 (* (-> obj header effect-count) 32)))) + (dotimes (effect-idx (the-as int (-> obj header effect-count))) + (let ((fctrl (-> obj effect effect-idx frag-ctrl))) + (dotimes (frag-idx (the-as int (-> obj effect effect-idx frag-count))) + (set! + ctrl-mem + (+ + ctrl-mem + (* (shr (+ (-> fctrl unsigned-four-count) 3) 2) 16) + (* (shr (+ (-> fctrl lump-four-count) 3) 2) 16) + (* (-> fctrl fp-qwc) 16) + (asize-of fctrl) + ) + ) + (set! + fctrl + (the-as + merc-fragment-control + (&+ (the-as pointer fctrl) (asize-of fctrl)) + ) + ) + ) + ) + ) + (set! (-> arg0 length) (max 76 (-> arg0 length))) + (set! (-> arg0 data 75 name) "merc-ctrl") + (+! (-> arg0 data 75 count) 1) + (+! (-> arg0 data 75 used) ctrl-mem) + (+! (-> arg0 data 75 total) (logand -16 (+ ctrl-mem 15))) + ) + (let ((effect-mem 0)) + (dotimes (effect-idx2 (the-as int (-> obj header effect-count))) + (when (nonzero? (-> obj effect effect-idx2 blend-frag-count)) + (let ((bctrl (-> obj effect effect-idx2 blend-ctrl))) + (dotimes + (blend-frag-idx + (the-as int (-> obj effect effect-idx2 blend-frag-count)) + ) + (let + ((v1-36 + (+ + effect-mem + (* + (+ (-> bctrl nonzero-index-count) 1) + (the-as + uint + (logand + (+ (* (the-as uint 6) (-> bctrl blend-vtx-count)) 15) + #xfff0 + ) + ) + ) + ) + ) + ) + (set! + effect-mem + (the-as int (+ (-> obj header blend-target-count) 2 v1-36)) + ) + ) + (set! + bctrl + (the-as + merc-blend-ctrl + (&+ (the-as pointer bctrl) (+ (-> obj header blend-target-count) 2)) + ) + ) + ) + ) + ) + ) + (when (nonzero? effect-mem) + (set! (-> arg0 length) (max 78 (-> arg0 length))) + (set! (-> arg0 data 77 name) "blend-shape") + (+! (-> arg0 data 77 count) 1) + (+! (-> arg0 data 77 used) effect-mem) + (+! (-> arg0 data 77 total) (logand -16 (+ effect-mem 15))) + ) + ) + (when (nonzero? (-> obj header eye-ctrl)) + (let ((a0-28 (-> obj header eye-ctrl))) + (set! (-> arg0 length) (max 109 (-> arg0 length))) + (set! (-> arg0 data 108 name) "eye-anim") + (+! (-> arg0 data 108 count) 1) + (let ((v1-47 (asize-of a0-28))) + (+! (-> arg0 data 108 used) v1-47) + (+! (-> arg0 data 108 total) (logand -16 (+ v1-47 15))) + ) + ) + ) + obj + ) + +;; definition for method 9 of type merc-ctrl +(defmethod login merc-ctrl ((obj merc-ctrl)) + (set! *merc-ctrl-header* (-> obj header)) + (dotimes (v1-1 3) + (set! (-> *merc-ctrl-header* masks v1-1) (the-as uint 0)) + ) + (dotimes (effect-idx (the-as int (-> obj header effect-count))) + (login-adgifs (-> obj effect effect-idx)) + ) + (let ((idx-with-bit1 -1) + (a1-1 (-> obj header effect-count)) + ) + (dotimes (v1-11 (the-as int a1-1)) + (if (logtest? (-> obj effect v1-11 effect-bits) 2) + (set! idx-with-bit1 v1-11) + ) + ) + (when (!= idx-with-bit1 -1) + (let ((v1-16 4) + (this-effect (-> obj effect idx-with-bit1)) + (last-effect (-> obj effect (+ a1-1 -1))) + ) + (dotimes (copy-idx v1-16) + (let ((a3-2 (-> this-effect data copy-idx))) + (set! (-> this-effect data copy-idx) (-> last-effect data copy-idx)) + (set! (-> last-effect data copy-idx) a3-2) + ) + ) + ) + ) + ) + (cond + ((zero? (logand -65536 (the-as int (-> obj header eye-ctrl)))) + (set! (-> obj header eye-ctrl) (the-as merc-eye-ctrl 0)) + 0 + ) + (else + (let ((s5-1 (-> obj header eye-ctrl))) + (dotimes (s4-0 3) + (let ((v1-25 (adgif-shader-login (-> s5-1 shader s4-0)))) + (when v1-25 + (dotimes (a0-11 3) + (logior! (-> *merc-ctrl-header* masks a0-11) (-> v1-25 masks a0-11)) + ) + ) + ) + ) + ) + ) + ) + obj + ) + +;; definition (debug) for function merc-stats-display +;; INFO: Return type mismatch symbol vs none. +(defun-debug merc-stats-display ((arg0 merc-ctrl)) + (format #t "~30s:" (-> arg0 name)) + (let ((s5-0 (-> arg0 header st-int-scale)) + (s4-0 (ash 1 (- 12 (the-as int (-> arg0 header st-int-scale))))) + ) + (format #t " ST ~3D, " s4-0) + (cond + ((>= s5-0 (the-as uint 5)) + (format #t "RANGE ~D+," (/ 128 s4-0)) + ) + ((= s5-0 4) + (format #t "RANGE 0.5+,") + ) + ) + ) + (dotimes (s5-1 (the-as int (-> arg0 header effect-count))) + (let ((s3-0 (-> arg0 effect s5-1))) + (if (nonzero? s5-1) + (format #t "~48s " " ") + ) + (let ((a2-4 (-> s3-0 frag-count)) + (s4-1 (-> s3-0 tri-count)) + (f30-0 (the float (-> s3-0 frag-count))) + (f28-0 (the float (-> s3-0 dvert-count))) + (f26-0 (the float (-> s3-0 tri-count))) + ) + (if (>= (/ (+ 50.0 f28-0) f30-0) 50.0) + (format #t "~3D frags, ~2,,1f dverts/frag " a2-4 (/ f28-0 f30-0)) + (format #t "~3D frags, ~2,,1f ******/**** " a2-4 (/ f28-0 f30-0)) + ) + (format + #t + "(~4D tris, striplen ~2,,2f, ~2,,1f tris/frag)~%" + s4-1 + (/ (* 2.0 f26-0) (- f28-0 f26-0)) + (/ f26-0 f30-0) + ) + ) + ) + ) + (none) + ) + +;; definition (debug) for function merc-stats +;; INFO: Return type mismatch int vs none. +(defun-debug merc-stats () + (dotimes (gp-0 3) + (let ((s5-0 (-> *level* level gp-0 art-group))) + (when (nonzero? s5-0) + (dotimes (s4-0 (-> s5-0 art-group-array length)) + (let ((s3-0 (-> s5-0 art-group-array s4-0))) + (dotimes (s2-0 (-> s3-0 length)) + (let* ((s1-0 (-> s3-0 data s2-0)) + (a0-3 + (if (and (nonzero? s1-0) (type-type? (-> s1-0 type) merc-ctrl)) + s1-0 + ) + ) + ) + (if a0-3 + (merc-stats-display (the-as merc-ctrl a0-3)) + ) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition (debug) for function merc-edge-stats +;; INFO: Return type mismatch int vs none. +(defun-debug merc-edge-stats () + (dotimes (gp-0 3) + (let ((s5-0 (-> *level* level gp-0 art-group))) + (when (nonzero? s5-0) + (dotimes (s4-0 (-> s5-0 art-group-array length)) + (let ((s3-0 (-> s5-0 art-group-array s4-0))) + (dotimes (s2-0 (-> s3-0 length)) + (let* ((s1-0 (-> s3-0 data s2-0)) + (v1-10 + (if (and (nonzero? s1-0) (type-type? (-> s1-0 type) merc-ctrl)) + s1-0 + ) + ) + ) + (if v1-10 + (format + #t + "~30s: ~f~%" + (-> (the-as merc-ctrl v1-10) name) + (-> (the-as merc-ctrl v1-10) header longest-edge) + ) + ) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for function merc-vu1-add-vu-function +;; INFO: Return type mismatch dma-packet vs dma-gif-packet. +(defun + merc-vu1-add-vu-function + ((dma dma-packet) (func vu-function) (flush-mode int)) + (let ((func-data (&-> func data 4)) + (qwc (-> func qlength)) + (dst (-> func origin)) + ) + (while (> qwc 0) + (let ((qwc-this-time (min 127 qwc))) + (set! + (-> dma dma) + (new 'static 'dma-tag + :id (dma-tag-id ref) + :qwc qwc-this-time + :addr (the-as int func-data) + ) + ) + (set! + (-> dma vif0) + (new 'static 'vif-tag :cmd (if (zero? flush-mode) 16 19)) + ) + (set! + (-> dma vif1) + (new 'static 'vif-tag + :cmd (vif-cmd mpg) + :num (* qwc-this-time 2) + :imm dst + ) + ) + (&+! dma 16) + (&+! func-data (* qwc-this-time 16)) + (set! qwc (- qwc qwc-this-time)) + (+! dst (* qwc-this-time 2)) + ) + ) + ) + (the-as dma-gif-packet dma) + ) + +;; definition for function merc-vu1-initialize-chain +;; INFO: Return type mismatch dma-packet vs none. +;; Used lq/sq +(defun merc-vu1-initialize-chain ((arg0 dma-gif-packet)) + (let + ((gp-0 + (the-as + object + (merc-vu1-add-vu-function (the-as dma-packet arg0) merc-vu1-block 1) + ) + ) + ) + (set! + (-> (the-as dma-gif-packet gp-0) dma-vif dma) + (new 'static 'dma-tag :qwc #xa :id (dma-tag-id cnt)) + ) + (set! + (-> (the-as dma-gif-packet gp-0) dma-vif vif0) + (new 'static 'vif-tag :imm #x404 :cmd (vif-cmd stcycl)) + ) + (set! + (-> (the-as dma-gif-packet gp-0) dma-vif vif1) + (new 'static 'vif-tag :cmd (vif-cmd stmod)) + ) + (set! + (-> (the-as (pointer vif-tag) gp-0) 4) + (new 'static 'vif-tag :imm #x1ba :cmd (vif-cmd base)) + ) + (set! + (-> (the-as (pointer vif-tag) gp-0) 5) + (new 'static 'vif-tag :imm #xfe46 :cmd (vif-cmd offset)) + ) + (set! (-> (the-as (pointer vif-tag) gp-0) 6) (new 'static 'vif-tag)) + (set! + (-> (the-as (pointer vif-tag) gp-0) 7) + (new 'static 'vif-tag :num #x8 :cmd (vif-cmd unpack-v4-32)) + ) + (let ((s5-0 (the-as merc-vu1-low-mem (&+ (the-as dma-gif-packet gp-0) 32)))) + (set! + (-> s5-0 tri-strip-gif tag) + (new 'static 'gif-tag64 + :pre #x1 + :prim (new 'static 'gs-prim :prim (gs-prim-type tri-strip) :iip #x1 :tme #x1 :fge #x1) + :nreg #x3 + ) + ) + (set! + (-> s5-0 tri-strip-gif regs) + (new 'static 'gif-tag-regs + :regs0 (gif-reg-id st) + :regs1 (gif-reg-id rgbaq) + :regs2 (gif-reg-id xyzf2) + ) + ) + (set! + (-> s5-0 tri-strip-gif word 3) + (shr (make-u128 0 (shl #x303e4000 32)) 32) + ) + (set! (-> s5-0 ad-gif tag) (new 'static 'gif-tag64 :nloop #x5 :nreg #x1)) + (set! + (-> s5-0 ad-gif regs) + (new 'static 'gif-tag-regs :regs0 (gif-reg-id a+d)) + ) + (set! (-> s5-0 hvdf-offset quad) (-> *math-camera* hvdf-off quad)) + (quad-copy! + (-> s5-0 perspective) + (the-as pointer (-> *math-camera* perspective)) + 4 + ) + (set-vector! + (-> s5-0 fog) + (-> *math-camera* pfog0) + (-> *math-camera* fog-min) + (-> *math-camera* fog-max) + 0.0 + ) + ) + (let ((v1-20 (-> (the-as (inline-array dma-packet) gp-0) 10))) + (set! (-> v1-20 dma) (new 'static 'dma-tag :id (dma-tag-id cnt))) + (set! (-> v1-20 vif0) (new 'static 'vif-tag)) + (set! + (-> v1-20 vif1) + (new 'static 'vif-tag :cmd (vif-cmd mscal) :msk #x1 :imm #x0) + ) + (&+ v1-20 16) + ) + ) + (none) + ) + +;; definition for function merc-vu1-init-buffer +;; INFO: Return type mismatch int vs none. +(defun merc-vu1-init-buffer ((dma-bucket bucket-id) (test gs-test) (arg2 int)) + (let + ((bucket + (-> + *display* + frames + (-> *display* on-screen) + frame + bucket-group + dma-bucket + ) + ) + ) + (when (!= bucket (-> bucket last)) + (let* + ((dma-buf (-> *display* frames (-> *display* on-screen) frame global-buf)) + (s3-1 (-> dma-buf base)) + ) + (set! + (-> dma-buf base) + (the-as + pointer + (merc-vu1-initialize-chain (the-as dma-gif-packet (-> dma-buf base))) + ) + ) + (let* ((v1-8 dma-buf) + (a0-6 (the-as object (-> v1-8 base))) + ) + (set! + (-> (the-as dma-packet a0-6) dma) + (new 'static 'dma-tag :qwc #x2 :id (dma-tag-id cnt)) + ) + (set! (-> (the-as dma-packet a0-6) vif0) (new 'static 'vif-tag)) + (set! + (-> (the-as dma-packet a0-6) vif1) + (new 'static 'vif-tag :imm #x2 :cmd (vif-cmd direct) :msk #x1) + ) + (set! (-> v1-8 base) (&+ (the-as pointer a0-6) 16)) + ) + (let* ((v1-9 dma-buf) + (a0-8 (the-as object (-> v1-9 base))) + ) + (set! + (-> (the-as gs-gif-tag a0-8) tag) + (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x1) + ) + (set! + (-> (the-as gs-gif-tag a0-8) 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-9 base) (&+ (the-as pointer a0-8) 16)) + ) + (let* ((v1-10 dma-buf) + (a0-10 (-> v1-10 base)) + ) + (set! (-> (the-as (pointer gs-test) a0-10) 0) test) + (set! (-> (the-as (pointer gs-reg64) a0-10) 1) (gs-reg64 test-1)) + (set! (-> v1-10 base) (&+ a0-10 16)) + ) + (let ((v1-11 (the-as object (-> dma-buf base)))) + (set! + (-> (the-as dma-packet v1-11) dma) + (new 'static 'dma-tag :id (dma-tag-id next) :addr (-> bucket next)) + ) + (set! (-> (the-as dma-packet v1-11) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet v1-11) vif1) (new 'static 'vif-tag)) + (set! (-> dma-buf base) (&+ (the-as pointer v1-11) 16)) + ) + (set! (-> bucket next) (the-as uint s3-1)) + ) + ) + ) + 0 + (none) + ) + +;; definition for function merc-vu1-init-buffers +;; INFO: Return type mismatch int vs none. +(defun merc-vu1-init-buffers () + (when (logtest? *vu1-enable-user* 1024) + (merc-vu1-init-buffer + (bucket-id bucket-10) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x26 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 0 + ) + (merc-vu1-init-buffer + (bucket-id bucket-49) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x26 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 0 + ) + (merc-vu1-init-buffer + (bucket-id bucket-17) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x26 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 0 + ) + (merc-vu1-init-buffer + (bucket-id bucket-52) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x26 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 0 + ) + (merc-vu1-init-buffer + (bucket-id bucket-45) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x26 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 0 + ) + (merc-vu1-init-buffer + (bucket-id bucket-55) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x26 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 0 + ) + (merc-vu1-init-buffer + (bucket-id bucket-58) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x80 + :afail #x1 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 0 + ) + (merc-vu1-init-buffer + (bucket-id bucket-61) + (new 'static 'gs-test + :ate #x1 + :atst (gs-atest greater-equal) + :aref #x80 + :afail #x1 + :zte #x1 + :ztst (gs-ztest greater-equal) + ) + 0 + ) + ) + 0 + (none) + ) diff --git a/test/decompiler/reference/engine/load/loader_REF.gc b/test/decompiler/reference/engine/load/loader_REF.gc index 7d52b956c5..320375eb6d 100644 --- a/test/decompiler/reference/engine/load/loader_REF.gc +++ b/test/decompiler/reference/engine/load/loader_REF.gc @@ -140,7 +140,7 @@ ) (let ((s5-0 (loado arg0 arg1))) (the-as art (if (type-type? (-> (the-as art s5-0) type) art) - (dummy-9 (the-as art s5-0)) + (login (the-as art s5-0)) (the-as art #f) ) ) @@ -190,7 +190,7 @@ (the-as art-group #f) ) (else - (dummy-9 s3-1) + (login s3-1) ) ) ) @@ -545,7 +545,7 @@ (set! (-> obj status) 'error) ) (else - (dummy-9 s4-0) + (login s4-0) (set! (-> obj status) 'locked) ) )