decomp: Decompile wind (#480)

* decomp: Decompile `wind`

* include `<limits>`

test/decompiler/reference/all_forward_declarations.gc

@@ -578,4 +578,9 @@
   (:methods
     (dummy-9 () none 9)
     )
-  )
+  )
+
+; This was likely originally defined inside `wind-h`
+; but the decompiler won't output it, so we have to manually define it
+(define-extern wind-work type)
+(define-extern *wind-work* wind-work)

test/decompiler/reference/engine/gfx/wind-h_REF.gc

@@ -0,0 +1,104 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition of type wind-vector
+(deftype wind-vector (structure)
+  ((wind-pos vector2w :inline :offset-assert 0)
+   (wind-vel vector2w :inline :offset-assert 8)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+;; definition for method 3 of type wind-vector
+(defmethod inspect wind-vector ((obj wind-vector))
+  (format #t "[~8x] ~A~%" obj 'wind-vector)
+  (format #t "~Twind-pos: #<vector2w @ #x~X>~%" (-> obj wind-pos))
+  (format #t "~Twind-vel: #<vector2w @ #x~X>~%" (-> obj wind-vel))
+  obj
+  )
+
+;; definition for symbol *wind-scales*, type (array uint8)
+(define
+  *wind-scales*
+  (the-as (array uint8)
+   (new
+    'static
+    'boxed-array
+    uint8
+    32
+    #x2
+    #x5
+    #x2
+    #x3
+    #x2
+    #x2
+    #x3
+    #x10
+    #xa
+    #x2
+    #x4
+    #x2
+    #x8
+    #x2
+    #x2
+    #x10
+    #x2
+    #x2
+    #x8
+    #x2
+    #x10
+    #x2
+    #x4
+    #x10
+    #xa
+    #x2
+    #x4
+    #x2
+    #x8
+    #x2
+    #x2
+    #x10
+    )
+   )
+  )
+
+;; definition of type wind-work
+(deftype wind-work (basic)
+  ((wind-array  vector 64 :inline :offset-assert 16)
+   (wind-normal vector :inline    :offset-assert 1040)
+   (wind-temp   vector :inline    :offset-assert 1056)
+   (wind-force  float  64         :offset-assert 1072)
+   (wind-time   uint32            :offset-assert 1328)
+   )
+  :method-count-assert 9
+  :size-assert         #x534
+  :flag-assert         #x900000534
+  )
+
+;; definition for method 3 of type wind-work
+(defmethod inspect wind-work ((obj wind-work))
+  (format #t "[~8x] ~A~%" obj (-> obj type))
+  (format #t "~Twind-array[64] @ #x~X~%" (-> obj wind-array))
+  (format #t "~Twind-normal: ~`vector`P~%" (-> obj wind-normal))
+  (format #t "~Twind-temp: ~`vector`P~%" (-> obj wind-temp))
+  (format #t "~Twind-force[64] @ #x~X~%" (-> obj wind-force))
+  (format #t "~Twind-time: ~D~%" (-> obj wind-time))
+  obj
+  )
+
+;; definition for function wind-get-hashed-index
+(defun wind-get-hashed-index ((arg0 vector))
+  (logand
+   (+
+    (+ (the int (-> arg0 x)) (the int (-> arg0 z)))
+    (the-as int (-> *wind-work* wind-time))
+    )
+   63
+   )
+  )
+
+
+
+

test/decompiler/reference/engine/gfx/wind_REF.gc

@@ -0,0 +1,82 @@
+;;-*-Lisp-*-
+(in-package goal)
+
+;; definition for symbol *wind-work*, type wind-work
+(define *wind-work* (new 'global 'wind-work))
+
+;; definition for function update-wind
+;; INFO: Return type mismatch int vs none.
+(defun update-wind ((arg0 wind-work) (arg1 (array uint8)))
+  (rlet ((vf0 :class vf)
+         (vf1 :class vf)
+         (vf2 :class vf)
+         )
+   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
+   (let*
+    ((f0-1 (+ (-> arg0 wind-normal w) (rand-vu-float-range -1024.0 1024.0)))
+     (f30-1 (- f0-1 (* (the float (the int (/ f0-1 65536.0))) 65536.0)))
+     )
+    (set! (-> arg0 wind-normal w) f30-1)
+    (set! (-> arg0 wind-normal x) (cos f30-1))
+    (set! (-> arg0 wind-normal z) (sin f30-1))
+    )
+   (set! (-> arg0 wind-time) (+ (-> arg0 wind-time) 1))
+   (let* ((s4-0 (logand (-> arg0 wind-time) 63))
+          (f0-4 (rand-vu-float-range 0.0 100.0))
+          (v1-5 (/ (-> arg0 wind-time) (the-as uint 120)))
+          (f1-6
+           (*
+            0.008333334
+            (the float (mod (-> arg0 wind-time) (the-as uint 120)))
+            )
+           )
+          (f2-4
+           (*
+            0.0625
+            (the float (-> arg1 (mod (the-as int v1-5) (-> arg1 length))))
+            )
+           )
+          (f0-5
+           (*
+            (+
+             (*
+              (-
+               (*
+                0.0625
+                (the
+                 float
+                 (-> arg1 (mod (the-as int (+ v1-5 1)) (-> arg1 length)))
+                 )
+                )
+               f2-4
+               )
+              f1-6
+              )
+             f2-4
+             )
+            f0-4
+            )
+           )
+          )
+    (set! (-> *wind-work* wind-force s4-0) f0-5)
+    (let ((v1-14 (-> *wind-work* wind-array s4-0)))
+     (let ((a0-15 (-> arg0 wind-normal)))
+      (.lvf vf1 (&-> a0-15 quad))
+      )
+     (let ((a0-16 f0-5))
+      (.mov vf2 a0-16)
+      )
+     (.add.x.vf vf1 vf0 vf0 :mask #b1000)
+     (.mul.x.vf vf1 vf1 vf2 :mask #b111)
+     (.svf (&-> v1-14 quad) vf1)
+     )
+    )
+   (let ((v0-4 0))
+    )
+   (none)
+   )
+  )
+
+
+
+