jak-project/test/decompiler/reference/all_forward_declarations.gc

;; GCOMMON
(define-extern name= (function basic basic symbol))
(define-extern fact (function int int))
(define-extern max (function int int int))
(define-extern min (function int int int))
(define-extern valid? (function object type basic basic object symbol))

;; KERNEL
(declare-type process basic)
(declare-type stack-frame basic)
(declare-type state basic)
(declare-type cpu-thread basic)
(declare-type dead-pool basic)
(declare-type event-message-block structure)
(declare-type thread basic)

(deftype process (process-tree)
  ((pool dead-pool :offset-assert #x20)
   (status basic :offset-assert #x24)
   (pid int32 :offset-assert #x28)
   (main-thread cpu-thread :offset-assert #x2c)
   (top-thread thread :offset-assert #x30)
   (entity basic :offset-assert #x34)
   (state state :offset-assert #x38)
   (trans-hook function :offset-assert #x3c)
   (post-hook function :offset-assert #x40)
   (event-hook (function basic int basic event-message-block object) :offset-assert #x44)
   (allocated-length int32 :offset-assert #x48)
   (next-state state :offset-assert #x4c)
   (heap-base pointer :offset-assert #x50)
   (heap-top pointer :offset-assert #x54)
   (heap-cur pointer :offset-assert #x58)
   (stack-frame-top stack-frame :offset-assert #x5c)
   (connection-list connectable :inline :offset-assert #x60)
   (stack uint8 :dynamic :offset-assert #x70)
   )

  (:methods
    (new (symbol type basic int) _type_ 0)
    (activate (_type_ process-tree basic pointer) process-tree 9)
    (deactivate  (process) none 10)
    (dummy-method-11 () none 11)
    (run-logic? (process) symbol 12)
    (dummy-method () none 13)
   )

  :size-assert #x70
  :method-count-assert 14
  :no-runtime-type ;; already defined by kscheme. Don't do it again.
  )

(declare-type dead-pool-heap basic)
(define-extern *debug-dead-pool* dead-pool-heap)
(define-extern change-parent (function process-tree process-tree process-tree))
(define-extern *null-process* process)
(define-extern *vis-boot* basic)
(define-extern *stdcon* string)
(declare-type kernel-context basic)
(define-extern iterate-process-tree (function process-tree (function object object) kernel-context object))
(define-extern execute-process-tree (function process-tree (function object object) kernel-context object))
(define-extern search-process-tree (function process-tree (function process-tree object) process-tree))

(define-extern *listener-process* process)
(define-extern *active-pool* process-tree)
(define-extern reset-and-call (function thread function object))
(defun ash ((value int) (shift-amount int))
  "Arithmetic shift value by shift-amount.
  A positive shift-amount will shift to the left and a negative will shift to the right.
  "
  ;; OpenGOAL does not support ash in the compiler, so we implement it here as an inline function.
  (declare (inline))
  (if (> shift-amount 0)
      (shl value shift-amount)
      (sar value (- shift-amount))
      )
  )
(define-extern inspect-process-tree (function process-tree int int symbol process-tree))
(define-extern set-to-run-bootstrap (function none))
(define-extern dead-state state)
(define-extern *display-pool* process-tree)
(define-extern *camera-pool* process-tree)
(define-extern *target-pool* process-tree)
(define-extern *entity-pool* process-tree)
(define-extern *default-pool* process-tree)
(define-extern *stdcon0* string)
(define-extern *stdcon1* string)
(define-extern *debug-draw-pauseable* symbol)

;; gstate
(define-extern enter-state (function object object object object object object object))
(define-extern throw (function symbol object int))
(defmacro suspend()
  '(none)
  )

(defmacro empty-form ()
  '(none)
  )

(defmacro gpr->fpr (in)
  in)

(define-extern get-current-time (function uint))
(define-extern get-integral-current-time (function uint))

;; math
(define-extern fabs (function float float))
(define-extern abs (function int int))
(define-extern rand-vu-init (function float none))
(define-extern rand-vu (function float))

;; matrix
(declare-type matrix structure)
(declare-type vector structure)
(define-extern matrix-transpose! (function matrix matrix matrix))
(define-extern sin (function float float))
(define-extern cos (function float float))
(define-extern vector-sincos! (function vector vector vector int))
(define-extern matrix-axis-sin-cos! (function matrix vector float float none))
(define-extern atan (function float float float))

;; transform
(define-extern vector-identity! (function vector vector))

;; quaternion
(define-extern acos (function float float))
(define-extern acos-rad (function float float))
(define-extern atan2-rad (function float float float))
(define-extern vector-length (function vector float))
(define-extern sincos-rad! (function (pointer float) float int))
(define-extern atan-series-rad (function float float))
(define-extern vector-sin-rad! (function vector vector vector))
(define-extern vector-rad<-vector-deg/2! (function vector vector int))
(define-extern vector-sincos-rad! (function vector vector vector int))
(define-extern deg-diff (function float float float))
(define-extern vector-xz-normalize! (function vector float vector))
(declare-type quaternion structure)
(define-extern quaternion-from-two-vectors-max-angle! (function quaternion vector vector float quaternion))
(define-extern vector-xz-length (function vector float))

;; trigonometry
(defconstant PI (the-as float #x40490fda))
(defconstant MINUS_PI (the-as float #xc0490fda))
(define-extern sin-rad (function float float))
(define-extern cos-rad (function float float))

(defmacro .sync.l ()
  `(none))

;; timer-h
(defenum timer-clock-selection
  :type uint8
  (busclk 0)
  (busclk/16 1)
  (busclk/256 2)
  (hblank 3)
  )

;; dma
(declare-type dma-buffer basic)

(defenum vif-cmd
    :bitfield #f
    :type uint8
    (nop          0)  ;; no-op, can still have irq set.
    (stcycl       1)  ;; set write recycle register
    (offset       2)  ;; set offset register
    (base         3)  ;; set base register
    (itop         4)  ;; set data pointer register (itops)
    (stmod        5)  ;; set mode register
    (mskpath3     6)  ;; set path 3 mask
    (mark         7)  ;; set mark register
    (flushe       16) ;; wait for end of microprogram
    (flush        17) ;; wait for end of microprogram and transfer (path1/path2)
    (flusha       19) ;; wait for end of microprogram and transfer (path1/path2/path3)
    (mscal        20) ;; activate microprogram (call)
    (mscalf       21) ;; flushe and activate (call)
    (mscnt        23) ;; activate microprogram (continue)
    (stmask       32) ;; set MASK register.
    (strow        48) ;; set filling data
    (stcol        49) ;; set filling data
    (mpg          74) ;; transfer microprogram
    (direct       80) ;; straight to GIF.
    (directhl     81)
    (unpack-s-32  96)
    (unpack-s-16  97)
    (unpack-s-8   98)
    ;; 99 is invllid
    (unpack-v2-32 100)
    (unpack-v2-16 101)
    (unpack-v2-8  102)
    ;; 103 is invalid
    (unpack-v3-32 104)
    (unpack-v3-16 105)
    (unpack-v3-8  106)
    ;; 107 is invalid
    (unpack-v4-32 108)
    (unpack-v4-16 109)
    (unpack-v4-8  110)
    (unpack-v4-5  111)
    (cmd-mask     239)
    )

(defenum vif-cmd-32
    :bitfield #f
    :type uint32
    :copy-entries vif-cmd
    )

(defenum dma-tag-id
    :bitfield #f
    :type uint8
    (refe 0)      ;; addr=ADDR, ends after this transfer
    (cnt 1)       ;; addr=after tag, next-tag=after data
    (next 2)      ;; addr=after tag, next-tag=ADDR
    (ref 3)       ;; addr=ADDR, next-tag=after tag
    (refs 4)      ;; ref, but stall controled
    (call 5)      ;;
    (ret 6)       ;;
    (end 7)       ;; next, but ends.
    )

(defenum gs-psm
    :bitfield #f
    :type uint8
    (ct32 0)
    (ct24 1)
    (ct16 2)
    (ct16s 10)
    (mt8 19)
    (mt4 20)
    (mt8h 27)
    (mt4hl 36)
    (mt4hh 44)
    (mz32 48)
    (mz24 49)
    (mz16 50)
    (mz16s 58)
    )
(defenum gs-prim-type
  :type uint8
  (point 0)
  (line 1)
  (line-strip 2)
  (tri 3)
  (tri-strip 4)
  (tri-fan 5)
  (sprite 6)
  )

(defenum gif-reg-id
  :bitfield #f
  :type uint8
  (prim 0)
  (rgbaq 1)
  (st 2)
  (uv 3)
  (xyzf2 4)
  (xyz2 5)
  (tex0-1 6)
  (tex0-2 7)
  (clamp-1 8)
  (clamp-2 9)
  (fog 10)
  (xyzf3 12)
  (xyz3 13)
  (a+d 14)
  (nop 15)
  )

(deftype gif-tag-regs (uint64)
  ((regs0   gif-reg-id :offset 0  :size 4)
   (regs1   gif-reg-id :offset 4  :size 4)
   (regs2   gif-reg-id :offset 8  :size 4)
   (regs3   gif-reg-id :offset 12  :size 4)
   (regs4   gif-reg-id :offset 16  :size 4)
   (regs5   gif-reg-id :offset 20  :size 4)
   (regs6   gif-reg-id :offset 24  :size 4)
   (regs7   gif-reg-id :offset 28  :size 4)
   (regs8   gif-reg-id :offset 32  :size 4)
   (regs9   gif-reg-id :offset 36 :size 4)
   (regs10  gif-reg-id :offset 40 :size 4)
   (regs11  gif-reg-id :offset 44 :size 4)
   (regs12  gif-reg-id :offset 48 :size 4)
   (regs13  gif-reg-id :offset 52 :size 4)
   (regs14  gif-reg-id :offset 56 :size 4)
   (regs15  gif-reg-id :offset 60 :size 4)
   )
  )


;; display-h
(declare-type display basic)
(define-extern set-display (function display int int int int int display))
(define-extern *display* display)

;; pad
(defenum pad-buttons
    :bitfield #t
    :type uint32
    (select   0)
    (l3       1)
    (r3       2)
    (start    3)
    (up       4)
    (right    5)
    (down     6)
    (left     7)
    (l2       8)
    (r2       9)
    (l1       10)
    (r1       11)
    (triangle 12)
    (circle   13)
    (x        14)
    (square   15)
    )

;; vector
;; only because trig isn't in the reference yet.
(define-extern deg-lerp-clamp (function float float float float))

;; file-io
(defenum file-kind
    :bitfield #f
    (level-bt 0) ;; aka bsp-header.
    (art-group 1)
    (tpage 2)
    (dir-tpage 3)
    (level-vs 4)
    (tx 5)
    (vis 6)
    )

;; loader-h
(declare-type art-group basic)

;; math-camera
(declare-type math-camera basic)
(define-extern *math-camera* math-camera)

;; level-h
(declare-type entity-links structure)
(declare-type level-group basic)
(define-extern *level* level-group)
(define-extern log2 (function int int))

(defenum gs-reg
  :type uint8
  (prim 0)
  (rgbaq 1)
  (st 2)
  (uv 3)
  (xyzf2 4)
  (xyz2 5)
  (tex0-1 6)
  (tex0-2 7)
  (clamp-1 8)
  (clamp-2 9)
  (fog 10)
  (xyzf3 12)
  (xyz3 13)
  (tex1-1 20)
  (tex1-2 21)
  (tex2-1 22)
  (tex2-2 23)
  (xyoffset-1 24)
  (xyoffset-2 25)
  (prmodecont 26)
  (prmode 27)
  (texclut 28)
  (scanmsk 34)
  (miptbp1-1 52)
  (miptbp1-2 53)
  (miptbp2-1 54)
  (miptbp2-2 55)
  (texa 59)
  (fogcol 61)
  (texflush 63)
  (scissor-1 64)
  (scissor-2 65)
  (alpha-1 66)
  (alpha-2 67)
  (dimx 68)
  (dthe 69)
  (colclamp 70)
  (test-1 71)
  (test-2 72)
  (pabe 73)
  (fba-1 74)
  (fba-2 75)
  (frame-1 76)
  (frame-2 77)
  (zbuf-1 78)
  (zbuf-2 79)
  (bitbltbuf 80)
  (trxpos 81)
  (trxreg 82)
  (trxdir 83)
  (hwreg 84)
  (signal 96)
  (finish 97)
  (label 98)
  )

(defenum gs-reg64
  :type uint64
  :copy-entries gs-reg
  )

;; connect
(declare-type engine basic)

(defmacro make-u128 (upper lower)
  `(rlet ((result :class i128)
          (upper-xmm :class i128)
          (lower-xmm :class i128))
     (.mov upper-xmm ,upper)
     (.mov lower-xmm ,lower)
     (.pcpyld result upper-xmm lower-xmm)
     result
     )
  )

;; texture

(declare-type texture-page basic)
(declare-type level basic)

;; main-h
(define-extern *dproc* process)

;; GEOMETRY - TODO
(define-extern vector-deg-slerp (function vector vector vector float vector))

;; bones - TODO
(declare-type vu-lights structure)
(declare-type light-group structure)
(define-extern vu-lights<-light-group! (function vu-lights light-group none))

;; game-h - TODO
(deftype process-drawable (process)
  ((root        basic   :offset-assert 112)
   (node-list   basic   :offset-assert 116)
   (draw        basic   :offset-assert 120)
   (skel        basic   :offset-assert 124)
   (nav         basic   :offset-assert 128)
   (align       basic   :offset-assert 132)
   (path        basic   :offset-assert 136)
   (vol         basic   :offset-assert 140)
   (fact        basic   :offset-assert 144)
   (link        basic   :offset-assert 148)
   (part        basic   :offset-assert 152)
   (water       basic   :offset-assert 156)
   (sound       basic   :offset-assert 160)
   (state-flags uint32  :offset-assert 164)
   (state-time  uint64  :offset-assert 168)
   )
  :heap-base #x40
  :method-count-assert 20
  :size-assert         #xb0
  :flag-assert         #x14004000b0
  ;; inherited inspect of process
  (:methods
    (dummy-14 () none 14)
    (dummy-15 () none 15)
    (dummy-16 () none 16)
    (dummy-17 () none 17)
    (dummy-18 () none 18)
    (dummy-19 () none 19)
    )
  )

;; game-h - TODO
(deftype vector (structure)
  ((data float 4 :offset-assert 0)
   (x float :offset 0)
   (y float :offset 4)
   (z float :offset 8)
   (w float :offset 12)
   (quad uint128 :offset 0)
   )
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

(deftype attack-info (structure)
  ((trans        vector :inline :offset-assert 0)
   (vector       vector :inline :offset-assert 16)
   (intersection vector :inline :offset-assert 32)
   (attacker     uint64         :offset-assert 48) ;; handle
   (invinc-time  uint64         :offset-assert 56)
   (mask         uint32         :offset-assert 64)
   (mode         basic          :offset-assert 68)
   (shove-back   float         :offset-assert 72) ;; meters
   (shove-up     float         :offset-assert 76) ;; meters
   (speed        float         :offset-assert 80) ;; meters
   (dist         float         :offset-assert 84) ;; meters
   (control      float          :offset-assert 88)
   (angle        basic          :offset-assert 92)
   (rotate-to    float            :offset-assert 96) ;; deg
   (prev-state   basic          :offset-assert 100)
   )
  :method-count-assert 10
  :size-assert         #x68
  :flag-assert         #xa00000068
  ;; field handle is likely a value type
  (:methods
    (dummy-9 () none 9)
    )
  )

;; definition of type quaternion
(deftype quaternion (structure)
  ((x    float                       :offset-assert 0)
   (y    float                       :offset-assert 4)
   (z    float                       :offset-assert 8)
   (w    float                       :offset-assert 12)
   (data float   4 :offset   0)
   (vec  vector  :inline :offset   0)
   (quad uint128 :offset   0)
   )
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

(deftype transform (structure)
  ((trans vector :inline :offset-assert 0)
   (rot   vector :inline :offset-assert 16)
   (scale vector :inline :offset-assert 32)
   )
  :method-count-assert 9
  :size-assert         #x30
  :flag-assert         #x900000030
  )

;; transformq
(deftype transformq (transform)
  ;; this overlays the rot field of transform.
  ((quat  quaternion :inline :offset 16)
   )
  :method-count-assert 9
  :size-assert         #x30
  :flag-assert         #x900000030
  )


(declare-type target basic)
(define-extern *target* target)

(declare-type sidekick basic)
(define-extern *sidekick* sidekick)

;; mood tables
(declare-type ocean-map basic)
(define-extern *ocean-map-village2* ocean-map)

(deftype continue-point (basic)
  ((name          basic           :offset-assert 4)
   (level         basic           :offset-assert 8)
   (flags         uint32          :offset-assert 12)
   (trans         vector  :inline :offset-assert 16)
   (quat          vector  :inline :offset-assert 32)
   (camera-trans  vector  :inline :offset-assert 48)
   (camera-rot    float 9       :offset-assert 64)
   (load-commands pair           :offset-assert 100)
   (vis-nick      basic           :offset-assert 104)
   (lev0          basic           :offset-assert 108)
   (disp0         basic           :offset-assert 112)
   (lev1          basic           :offset-assert 116)
   (disp1         basic           :offset-assert 120)
   )
  :method-count-assert 10
  :size-assert         #x7c
  :flag-assert         #xa0000007c
  (:methods
    (dummy-9 () none 9)
    )
  )