mirror/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project synced 2026-06-06 19:52:01 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
af49ac60cdddfda8c8a2afcc7aed4f5548e90c88
jak-project/test/decompiler/reference/all_forward_declarations.gc
T
water111 d79937fb62 Improve forward declaring types (#596) 
* improve forward declare type

* display type differences

* make codacy happy
2021-06-15 21:03:55 -04:00

1095 lines
31 KiB
Common Lisp
Raw Blame History

;; 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) ;; Pretty sure this needs to be a res-lump, but get `not fully defined error`s
(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)
)
(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)
(the uint 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
(declare-type trsqv basic)
(declare-type draw-control basic)
;; 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 plane (vector)
((a float :offset 0)
(b float :offset 4)
(c float :offset 8)
(d float :offset 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; 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)
)
)
; This was likely originally defined inside `wind-h`
; but the decompiler won't output it, so we have to manually define it
(declare-type wind-work basic)
(define-extern *wind-work* wind-work)
(define-extern vector-y-angle (function vector float))
(define-extern atan0 (function float float float))
(define-extern vector-rad<-vector-deg! (function vector vector none))
(define-extern vector-rad<-vector-deg/2! (function vector vector int))
(define-extern sprite-distorter-generate-tables (function none))
(defenum load-msg-result
:type uint16
:bitfield #f
(done 0)
(error 1)
(more 2)
(aborted 3)
(invalid 666)
)
(declare-type rpc-buffer-pair basic)
(define-extern string->sound-name (function string uint128))
(define-extern *dgo-name* string)
(define-extern *load-dgo-rpc* rpc-buffer-pair)
(define-extern *load-str-rpc* rpc-buffer-pair)
(define-extern *play-str-rpc* rpc-buffer-pair)
(define-extern *load-str-lock* symbol)
(define-extern *que-str-lock* symbol)
(define-extern get-video-mode (function symbol))
(define-extern draw-string-xy (function string dma-buffer int int int int none))
(declare-type game-info basic)
(define-extern *game-info* game-info)
;; shadow-cpu
(deftype shadow-settings (structure)
((center vector :inline :offset-assert 0)
(flags int32 :offset 12)
(shadow-dir vector :inline :offset-assert 16)
(dist-to-locus float :offset 28)
(bot-plane plane :inline :offset-assert 32)
(top-plane plane :inline :offset-assert 48)
(fade-dist float :offset-assert 64)
(fade-start float :offset-assert 68)
(dummy-2 int32 :offset-assert 72)
(dummy-3 int32 :offset-assert 76)
)
:method-count-assert 9
:size-assert #x50
:flag-assert #x900000050
)
(defmacro init-vf0-vector ()
"Initializes the VF0 vector which is a constant vector in the VU set to <0,0,0,1>"
`(.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
)
;; TODO - for trajectory.gc
(declare-type trajectory structure)
(deftype rgba (uint32)
((r uint8 :offset 0)
(g uint8 :offset 8)
(b uint8 :offset 16)
(a uint8 :offset 24)
)
:flag-assert #x900000004
)
(define-extern add-debug-line (function symbol int vector vector rgba symbol int int))
;; early declarations for draw-control
(declare-type ripple-control basic)
(declare-type shadow-geo basic)
(declare-type shadow-control basic)
;; early declarations for lod-group
(declare-type merc-ctrl basic)
;; TODO - for ripple
(define-extern add-debug-sphere (function symbol int vector float int int))
(defconstant SYM_TO_STRING_OFFSET #xff38)
(defmacro symbol->string (sym)
"Convert a symbol to a goal string."
`(-> (the-as (pointer string) (+ SYM_TO_STRING_OFFSET (the-as int ,sym))))
)
(defmacro new-stack-matrix0 ()
"Get a new matrix on the stack that's set to zero."
`(let ((mat (new 'stack-no-clear 'matrix)))
(set! (-> mat quad 0) (the-as uint128 0))
(set! (-> mat quad 1) (the-as uint128 0))
(set! (-> mat quad 2) (the-as uint128 0))
(set! (-> mat quad 3) (the-as uint128 0))
mat
)
)
(defmacro new-stack-vector0 ()
"Get a stack vector that's set to 0.
This is more efficient than (new 'stack 'vector) because
this doesn't call the constructor."
`(let ((vec (new 'stack-no-clear 'vector)))
(set! (-> vec quad) (the-as uint128 0))
vec
)
)
;; TODO - for entity-h
(declare-type nav-mesh basic)
(define-extern entity-nav-login function)
;; NOTE - forward declaration needed for cam-interface
(define-extern *camera-dummy-vector* vector)
(define-extern send-event-function (function process event-message-block object))
(define-extern *debug-engine* engine)
(deftype res-tag-pair (uint64)
((lo uint32 :offset 0)
(hi uint32 :offset 32)
)
)
(declare-type surface basic)
(define-extern *tread-surface* surface)
(define-extern *ice-surface* surface)
(define-extern *tar-surface* surface)
(define-extern *quicksand-surface* surface)
(define-extern *slope-surface* surface)
(define-extern *wade-surface* surface)
(define-extern *edge-surface* surface)
(define-extern *stone-surface* surface)
(define-extern *flop-land-mods* surface)
(define-extern *uppercut-jump-mods* surface)
(define-extern *duck-mods* surface)
(define-extern *pole-mods* surface)
(define-extern *grab-mods* surface)
(define-extern *edge-grab-mods* surface)
(define-extern *grass-surface* surface)
(defenum pat-material
:type uint8
(stone)
(ice)
(quicksand)
(waterbottom)
(tar)
(sand)
(wood)
(grass)
(pcmetal)
(snow)
(deepsnow)
(hotcoals)
(lava)
(crwood)
(gravel)
(dirt)
(metal)
(straw)
(tube)
(swamp)
(stopproj)
(rotate)
(neutral)
)
(defenum pat-mode
:type uint8
(ground)
(wall)
(obstacle)
)
(defenum pat-event
:type uint8
(none)
(deadly)
(endlessfall)
(burn)
(deadlyup)
(burnup)
(melt)
)
(defenum pickup-type
(none)
(eco-yellow)
(eco-red)
(eco-blue)
(eco-green)
(money)
(fuel-cell)
(eco-pill)
(buzzer)
(eco-pill-random)
)
(define-extern process-drawable-art-error state)
(define-extern *res-static-buf* pointer)
(define-extern vector-dot (function vector vector float))
(declare-type cspace structure)
(define-extern joint-mod-look-at-handler (function cspace transformq none))
(define-extern joint-mod-world-look-at-handler (function cspace transformq none))
(define-extern joint-mod-rotate-handler (function cspace transformq none))
(define-extern joint-mod-joint-set-handler (function cspace transformq none))
(define-extern joint-mod-joint-set*-handler (function cspace transformq none))
(defenum joint-mod-handler-mode
:bitfield #t
:type uint32
(flex-blend 0) ;; 1
(look-at 1) ;; 2
(world-look-at 2) ;; 4
(rotate 3) ;; 8
(joint-set 4) ;; 16
(joint-set* 5) ;; 32
;; ?? ;; 64
(reset 7) ;; 128
)
(defenum bucket-id
:type uint32
:bitfield #f
(tfrag-tex0 5)
;; merc0 10
;; generic0 11
(tfrag-tex1 12)
;; merc1 17
;; generic1 18
(shrub-tex0 19)
(shrub-tex1 25)
(alpha-tex0 31)
(alpha-tex1 38)
(pris-tex0 48)
;; merc0 49
;; generic0 50
(pris-tex1 51)
;; merc1 52
;; generic1 53
(water-tex0 57)
;; merc0 58 (+ default)
;; generic0 59 (+ default)
(water-tex1 60)
;; merc1 61
;; generic1 62
;; debug text 68
(debug-draw 68)
)
(define-extern cspace<-parented-transformq-joint! (function cspace transformq none))
(define-extern cspace<-transformq! (function cspace transformq matrix))
(define-extern vector<-cspace! (function vector cspace vector))
(define-extern add-debug-text-sphere (function symbol bucket-id vector float string rgba none))
(define-extern add-debug-matrix (function symbol bucket-id matrix none))
(define-extern vector-flatten! (function vector vector vector vector))
(defenum collide-list-enum
(hit-by-player)
(usually-hit-by-player)
(hit-by-others)
(player)
)
(declare-type collide-cache-tri structure)
(declare-type joint-control basic)
(declare-type process-drawable basic)
(declare-type joint-control-channel structure)
(define-extern cspace-index-by-name (function process-drawable string int))
(define-extern cspace-by-name (function process-drawable string cspace))
(define-extern joint-control-reset! (function joint-control joint-control-channel none))
;; TODO - for credits
(define-extern scf-get-territory (function int))
(declare-type font-context basic)
(define-extern print-game-text (function string font-context symbol int int float)) ; TODO decomp error, this seems correct though
; TODO - for cam-update-h
(define-extern *camera-look-through-other* int)
(define-extern *camera-other-trans* vector)
(define-extern *camera-other-root* vector)
(declare-type bsp-header basic)
(declare-type bsp-node structure)
(define-extern inspect-bsp-tree (function bsp-header bsp-node none))
(declare-type entity-camera basic)
(define-extern map-bsp-tree (function (function bsp-node none) bsp-header bsp-node none))
(deftype vif-tag (uint32)
((imm uint16 :offset 0 :size 16)
(num uint8 :offset 16 :size 8)
(cmd vif-cmd :offset 24 :size 7)
(irq uint8 :offset 31 :size 1)
(msk uint8 :offset 28 :size 1)
)
:method-count-assert 9
:size-assert #x4
:flag-assert #x900000004
)
(deftype dma-tag (uint64)
((qwc uint16 :offset 0) ;; quadword count
(pce uint8 :offset 26 :size 2) ;; priority (source mode)
(id dma-tag-id :offset 28 :size 3) ;; ID (what the tag means)
(irq uint8 :offset 31 :size 1) ;; interrupt at the end?
(addr uint32 :offset 32 :size 31) ;; address (31 bits)
(spr uint8 :offset 63 :size 1) ;; spr or not flag.
)
:method-count-assert 9
:size-assert #x8
:flag-assert #x900000008
)
(deftype dma-packet (structure)
((dma dma-tag :offset-assert 0)
(vif0 vif-tag :offset-assert 8)
(vif1 vif-tag :offset-assert 12)
(quad uint128 :offset 0)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
(deftype shadow-data (structure)
((texoffset vector :inline :offset-assert 0)
(texscale vector :inline :offset-assert 16)
(clrs uint128 2 :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)
(pdc basic :offset-assert 96)
(dist float :offset-assert 100)
(oddeven uint8 :offset-assert 104)
(waits uint32 :offset-assert 108)
)
:method-count-assert 9
:size-assert #x70
:flag-assert #x900000070
)
(deftype shadow-work (structure)
((shadow-data shadow-data :inline :offset-assert 0)
(inbuf uint128 600 :offset-assert 112)
)
:method-count-assert 9
:size-assert #x25f0
:flag-assert #x9000025f0
)
(defenum entity-perm-status
:bitfield #t
:type uint16
(bit-1 1)
(dead 2)
(complete 6))
(defenum sound-command
:type uint16
(load-bank)
(load-music)
(unload-bank)
(play)
(pause-sound)
(stop-sound)
(continue-sound)
(set-param)
(set-master-volume)
(pause-group)
(stop-group)
(continue-group)
(get-irx-version)
(set-falloff-curve)
(set-sound-falloff)
(reload-info)
(set-language)
(set-flava)
(set-reverb)
(set-ear-trans)
(shutdown)
(list-sounds)
(unload-music)
)
(declare-type res-lump basic)
(declare-type entity res-lump)
;; TODO - for prototype
(declare-type adgif-shader structure)
(define-extern adgif-shader-login-no-remap (function adgif-shader none))
;; TODO - for video
(declare-type setting-control basic)
(define-extern *setting-control* setting-control)
(declare-type shadow-control basic)
(define-extern *shadow-data* shadow-data)
(define-extern *pause-context* font-context)
(define-extern *profile-y* int)
(define-extern get-aspect-ratio (function symbol))
(declare-type video-parms structure)
(define-extern set-hud-aspect-ratio (function symbol symbol none))
(deftype progress (process)
((current-debug-string int32 :offset-assert 112)
(current-debug-language int32 :offset-assert 116)
(current-debug-group int32 :offset-assert 120)
(in-out-position int32 :offset-assert 124)
(display-state uint64 :offset-assert 128)
(next-display-state uint64 :offset-assert 136)
(option-index int32 :offset-assert 144)
(selected-option basic :offset-assert 148)
(completion-percentage float :offset-assert 152)
(ready-to-run basic :offset-assert 156)
(display-level-index int32 :offset-assert 160)
(next-level-index int32 :offset-assert 164)
(task-index int32 :offset-assert 168)
(in-transition basic :offset-assert 172)
(last-in-transition basic :offset-assert 176)
(force-transition basic :offset-assert 180)
(stat-transition basic :offset-assert 184)
(level-transition int32 :offset-assert 188)
(language-selection uint64 :offset-assert 192)
(language-direction basic :offset-assert 200)
(language-transition basic :offset-assert 204)
(language-x-offset int32 :offset-assert 208)
(sides-x-scale float :offset-assert 212)
(sides-y-scale float :offset-assert 216)
(left-x-offset int32 :offset-assert 220)
(right-x-offset int32 :offset-assert 224)
(button-scale float :offset-assert 228)
(slot-scale float :offset-assert 232)
(left-side-x-scale float :offset-assert 236)
(left-side-y-scale float :offset-assert 240)
(right-side-x-scale float :offset-assert 244)
(right-side-y-scale float :offset-assert 248)
(small-orb-y-offset int32 :offset-assert 252)
(big-orb-y-offset int32 :offset-assert 256)
(transition-offset int32 :offset-assert 260)
(transition-offset-invert int32 :offset-assert 264)
(transition-percentage float :offset-assert 268)
(transition-percentage-invert float :offset-assert 272)
(transition-speed float :offset-assert 276)
(total-nb-of-power-cells int32 :offset-assert 280)
(total-nb-of-orbs int32 :offset-assert 284)
(total-nb-of-buzzers int32 :offset-assert 288)
(card-info mc-slot-info :offset-assert 292)
(last-option-index-change uint64 :offset-assert 296)
(video-mode-timeout uint64 :offset-assert 304)
(display-state-stack uint64 5 :offset-assert 312)
(option-index-stack uint32 5 :offset-assert 352)
(display-state-pos int32 :offset-assert 372)
(nb-of-icons int32 :offset-assert 376)
(icons uint32 6 :offset-assert 380)
(max-nb-of-particles int32 :offset-assert 404)
(nb-of-particles int32 :offset-assert 408)
(particles uint32 40 :offset-assert 412)
(particle-state uint32 40 :offset-assert 572)
)
:method-count-assert 59
:size-assert #x2dc
:flag-assert #x3b000002dc
(: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)
(dummy-20 () none 20)
(dummy-21 () none 21)
(dummy-22 () none 22)
(TODO-RENAME-23 (_type_ symbol symbol) none 23)
(dummy-24 () none 24)
(dummy-25 () none 25)
(dummy-26 () none 26)
(dummy-27 () none 27)
(dummy-28 () none 28)
(dummy-29 () none 29)
(dummy-30 () none 30)
(dummy-31 () none 31)
(dummy-32 () none 32)
(dummy-33 () none 33)
(dummy-34 () none 34)
(dummy-35 () none 35)
(dummy-36 () none 36)
(dummy-37 () none 37)
(dummy-38 () none 38)
(dummy-39 () none 39)
(dummy-40 () none 40)
(dummy-41 () none 41)
(dummy-42 () none 42)
(dummy-43 () none 43)
(dummy-44 () none 44)
(dummy-45 () none 45)
(dummy-46 () none 46)
(dummy-47 () none 47)
(dummy-48 () none 48)
(dummy-49 () none 49)
(dummy-50 () none 50)
(dummy-51 () none 51)
(dummy-52 () none 52)
(dummy-53 () none 53)
(dummy-54 () none 54)
(dummy-55 () none 55)
(dummy-56 () none 56)
(dummy-57 () none 57)
(dummy-58 () none 58)
)
)
(define-extern *progress-process* (pointer progress))
(declare-type art-element basic)
(declare-type water-control basic)
(declare-type joint-anim-compressed-hdr structure)
(define-extern entity-by-name (function string entity))
(define-extern entity-by-aid (function uint entity))
(declare-type nav-mesh basic)
(define-extern *default-nav-mesh* nav-mesh)
(defenum path-control-flag
:bitfield #t
:type uint32
(display 0)
(not-found 4)
)
(defenum nav-control-flags
:bitfield #t
:type uint32
(display-marks 0)
(bit8 8)
(bit13 13)
)
(defmacro with-pp (&rest body)
`(rlet ((pp :reg r13 :reset-here #t :type process))
,@body)
)
Reference in New Issue View Git Blame Copy Permalink