Files
jak-project/test/decompiler/reference/jak2/engine/ui/minimap-h_REF.gc
T
ManDude cd68cb671e deftype and defmethod syntax major changes (#3094)
Major change to how `deftype` shows up in our code:
- the decompiler will no longer emit the `offset-assert`,
`method-count-assert`, `size-assert` and `flag-assert` parameters. There
are extremely few cases where having this in the decompiled code is
helpful, as the types there come from `all-types` which already has
those parameters. This also doesn't break type consistency because:
  - the asserts aren't compared.
- the first step of the test uses `all-types`, which has the asserts,
which will throw an error if they're bad.
- the decompiler won't emit the `heap-base` parameter unless necessary
now.
- the decompiler will try its hardest to turn a fixed-offset field into
an `overlay-at` field. It falls back to the old offset if all else
fails.
- `overlay-at` now supports field "dereferencing" to specify the offset
that's within a field that's a structure, e.g.:
```lisp
(deftype foobar (structure)
  ((vec    vector  :inline)
   (flags  int32   :overlay-at (-> vec w))
   )
  )
```
in this structure, the offset of `flags` will be 12 because that is the
final offset of `vec`'s `w` field within this structure.
- **removed ID from all method declarations.** IDs are only ever
automatically assigned now. Fixes #3068.
- added an `:overlay` parameter to method declarations, in order to
declare a new method that goes on top of a previously-defined method.
Syntax is `:overlay <method-name>`. Please do not ever use this.
- added `state-methods` list parameter. This lets you quickly specify a
list of states to be put in the method table. Same syntax as the
`states` list parameter. The decompiler will try to put as many states
in this as it can without messing with the method ID order.

Also changes `defmethod` to make the first type definition (before the
arguments) optional. The type can now be inferred from the first
argument. Fixes #3093.

---------

Co-authored-by: Hat Kid <6624576+Hat-Kid@users.noreply.github.com>
2023-10-30 03:20:02 +00:00

598 lines
24 KiB
Common Lisp
Vendored
Generated

;;-*-Lisp-*-
(in-package goal)
;; definition of type minimap-class-node
(deftype minimap-class-node (structure)
((default-position vector :inline)
(flags minimap-flag)
(class minimap-class)
(name basic)
(icon-xy vector2ub :inline)
(scale float)
(color rgba)
)
:pack-me
)
;; definition for method 3 of type minimap-class-node
(defmethod inspect ((this minimap-class-node))
(when (not this)
(set! this this)
(goto cfg-179)
)
(format #t "[~8x] ~A~%" this 'minimap-class-node)
(format #t "~1Tdefault-position: ~`vector`P~%" (-> this default-position))
(format #t "~1Tflags: #x~X : (minimap-flag " (-> this flags))
(let ((s5-0 (-> this flags)))
(if (= (logand s5-0 (minimap-flag active)) (minimap-flag active))
(format #t "active ")
)
(if (= (logand s5-0 (minimap-flag bigmap)) (minimap-flag bigmap))
(format #t "bigmap ")
)
(if (= (logand s5-0 (minimap-flag fade-in)) (minimap-flag fade-in))
(format #t "fade-in ")
)
(if (= (logand s5-0 (minimap-flag racer)) (minimap-flag racer))
(format #t "racer ")
)
(if (= (logand s5-0 (minimap-flag task)) (minimap-flag task))
(format #t "task ")
)
(if (= (logand s5-0 (minimap-flag enemy)) (minimap-flag enemy))
(format #t "enemy ")
)
(if (= (logand s5-0 (minimap-flag clamp)) (minimap-flag clamp))
(format #t "clamp ")
)
(if (= (logand s5-0 (minimap-flag minimap)) (minimap-flag minimap))
(format #t "minimap ")
)
(if (= (logand s5-0 (minimap-flag flash)) (minimap-flag flash))
(format #t "flash ")
)
(if (= (logand s5-0 (minimap-flag task-graph)) (minimap-flag task-graph))
(format #t "task-graph ")
)
(if (= (logand s5-0 (minimap-flag trail)) (minimap-flag trail))
(format #t "trail ")
)
(if (= (logand s5-0 (minimap-flag frustum)) (minimap-flag frustum))
(format #t "frustum ")
)
(if (= (logand s5-0 (minimap-flag background)) (minimap-flag background))
(format #t "background ")
)
(if (= (logand s5-0 (minimap-flag goal)) (minimap-flag goal))
(format #t "goal ")
)
(if (= (logand s5-0 (minimap-flag fade-out)) (minimap-flag fade-out))
(format #t "fade-out ")
)
(if (= (logand s5-0 (minimap-flag city-only)) (minimap-flag city-only))
(format #t "city-only ")
)
)
(format #t ")~%")
(let ((t9-20 format)
(a0-37 #t)
(a1-20 "~1Tclass: #x~X : ~S~%")
(a2-3 (-> this class))
(v1-50 (-> this class))
)
(t9-20 a0-37 a1-20 a2-3 (cond
((= v1-50 (minimap-class onintent))
"onintent"
)
((= v1-50 (minimap-class slumc-seal))
"slumc-seal"
)
((= v1-50 (minimap-class bbush-gena-2))
"bbush-gena-2"
)
((= v1-50 (minimap-class forest-samos))
"forest-samos"
)
((= v1-50 (minimap-class mountain-lens))
"mountain-lens"
)
((= v1-50 (minimap-class atoll))
"atoll"
)
((= v1-50 (minimap-class guard))
"guard"
)
((= v1-50 (minimap-class garage))
"garage"
)
((= v1-50 (minimap-class bbush-slumb-2))
"bbush-slumb-2"
)
((= v1-50 (minimap-class bbush-genb))
"bbush-genb"
)
((= v1-50 (minimap-class ruins-hut))
"ruins-hut"
)
((= v1-50 (minimap-class mountain-gear))
"mountain-gear"
)
((= v1-50 (minimap-class bbush-stadium))
"bbush-stadium"
)
((= v1-50 (minimap-class racer-target))
"racer-target"
)
((= v1-50 (minimap-class bbush-port-3))
"bbush-port-3"
)
((= v1-50 (minimap-class mountain))
"mountain"
)
((= v1-50 (minimap-class none))
"none"
)
((= v1-50 (minimap-class racer-errol))
"racer-errol"
)
((= v1-50 (minimap-class goal))
"goal"
)
((= v1-50 (minimap-class goal-no-trail))
"goal-no-trail"
)
((= v1-50 (minimap-class hideout))
"hideout"
)
((= v1-50 (minimap-class vinroom))
"vinroom"
)
((= v1-50 (minimap-class castle))
"castle"
)
((= v1-50 (minimap-class racer))
"racer"
)
((= v1-50 (minimap-class tanker))
"tanker"
)
((= v1-50 (minimap-class dig))
"dig"
)
((= v1-50 (minimap-class bbush-genb-2))
"bbush-genb-2"
)
((= v1-50 (minimap-class canyon))
"canyon"
)
((= v1-50 (minimap-class consite))
"consite"
)
((= v1-50 (minimap-class bbush-markb))
"bbush-markb"
)
((= v1-50 (minimap-class gungame))
"gungame"
)
((= v1-50 (minimap-class port-turret))
"port-turret"
)
((= v1-50 (minimap-class kiosk))
"kiosk"
)
((= v1-50 (minimap-class bbush-marka))
"bbush-marka"
)
((= v1-50 (minimap-class bbush-inda))
"bbush-inda"
)
((= v1-50 (minimap-class burning-bush))
"burning-bush"
)
((= v1-50 (minimap-class palace-cable))
"palace-cable"
)
((= v1-50 (minimap-class bbush-genc))
"bbush-genc"
)
((= v1-50 (minimap-class atoll-ashelin))
"atoll-ashelin"
)
((= v1-50 (minimap-class forest))
"forest"
)
((= v1-50 (minimap-class bbush-pal))
"bbush-pal"
)
((= v1-50 (minimap-class tomb))
"tomb"
)
((= v1-50 (minimap-class mountain-shard))
"mountain-shard"
)
((= v1-50 (minimap-class ruins))
"ruins"
)
((= v1-50 (minimap-class bbush-farmb))
"bbush-farmb"
)
((= v1-50 (minimap-class kid))
"kid"
)
((= v1-50 (minimap-class atoll-valve))
"atoll-valve"
)
((= v1-50 (minimap-class bbush-farma))
"bbush-farma"
)
((= v1-50 (minimap-class parking-spot))
"parking-spot"
)
((= v1-50 (minimap-class bbush-slumc))
"bbush-slumc"
)
((= v1-50 (minimap-class palace))
"palace"
)
((= v1-50 (minimap-class bbush-genc-2))
"bbush-genc-2"
)
((= v1-50 (minimap-class bbush-markb-2))
"bbush-markb-2"
)
((= v1-50 (minimap-class hiphog))
"hiphog"
)
((= v1-50 (minimap-class gun-dark))
"gun-dark"
)
((= v1-50 (minimap-class flag))
"flag"
)
((= v1-50 (minimap-class guard-frustum))
"guard-frustum"
)
((= v1-50 (minimap-class bbush-port-2))
"bbush-port-2"
)
((= v1-50 (minimap-class bbush-port))
"bbush-port"
)
((= v1-50 (minimap-class bbush-slumb))
"bbush-slumb"
)
((= v1-50 (minimap-class bbush-gena))
"bbush-gena"
)
((= v1-50 (minimap-class fortress))
"fortress"
)
((= v1-50 (minimap-class sewer))
"sewer"
)
((= v1-50 (minimap-class bbush-sluma))
"bbush-sluma"
)
((= v1-50 (minimap-class metalhead))
"metalhead"
)
((= v1-50 (minimap-class underport))
"underport"
)
((= v1-50 (minimap-class bbush-indb))
"bbush-indb"
)
((= v1-50 (minimap-class oracle))
"oracle"
)
((= v1-50 (minimap-class gun-yellow))
"gun-yellow"
)
((= v1-50 (minimap-class bbush-pal-2))
"bbush-pal-2"
)
((= v1-50 (minimap-class stadium))
"stadium"
)
(else
"*unknown*"
)
)
)
)
(format #t "~1Tname: ~A~%" (-> this name))
(format #t "~1Ticon-xy: #<vector2ub @ #x~X>~%" (-> this icon-xy))
(format #t "~1Tscale: ~f~%" (-> this scale))
(format #t "~1Tcolor: #x~X~%" (-> this color))
(label cfg-179)
this
)
;; definition of type connection-minimap
(deftype connection-minimap (connection-pers)
((handle handle :overlay-at update-time)
(position object :overlay-at param-quat)
(alpha float :overlay-at (-> param-float 1))
(class minimap-class-node :overlay-at (-> param-float 2))
(flags minimap-flag :overlay-at (-> param 3))
(node uint16 :offset 30)
(edge-ry float)
(last-world-pos vector :inline)
(last-relative-pos vector :inline)
)
)
;; definition for method 3 of type connection-minimap
;; INFO: Used lq/sq
(defmethod inspect ((this connection-minimap))
(when (not this)
(set! this this)
(goto cfg-48)
)
(format #t "[~8x] ~A~%" this 'connection-minimap)
(format #t "~1Tnext: #<connection-minimap @ #x~X>~%" (-> this next))
(format #t "~1Tkey: ~A~%" (-> this key))
(format #t "~1Tupdate-time: ~D~%" (-> this handle))
(format #t "~1Tparam[4] @ #x~X~%" (-> this param))
(dotimes (s5-0 4)
(format #t "~T [~D]~1Tparam: ~A~%" s5-0 (-> this param s5-0))
)
(format #t "~1Tparam-int32[4] @ #x~X~%" (-> this param))
(dotimes (s5-1 4)
(format #t "~T [~D]~1Tparam-int32: ~D~%" s5-1 (-> this param s5-1))
)
(format #t "~1Tparam-int64[2] @ #x~X~%" (-> this param))
(dotimes (s5-2 2)
(format #t "~T [~D]~1Tparam-int64: ~D~%" s5-2 (-> this param-int64 s5-2))
)
(format #t "~1Tparam-float[4] @ #x~X~%" (-> this param))
(dotimes (s5-3 4)
(format #t "~T [~D]~1Tparam-float: ~f~%" s5-3 (the-as float (-> this param s5-3)))
)
(format #t "~1Tparam-quat: #x~X~%" (-> this param-quat))
(format #t "~1Thandle: ~D~%" (-> this handle))
(format #t "~1Tposition: #<vector @ #x~X>~%" (-> this position))
(format #t "~1Talpha: ~f~%" (-> this alpha))
(format #t "~1Tclass: #<minimap-class-node @ #x~X>~%" (-> this class))
(format #t "~1Tflags: #x~X : (minimap-flag " (-> this flags))
(let ((s5-4 (-> this flags)))
(if (= (logand s5-4 (minimap-flag active)) (minimap-flag active))
(format #t "active ")
)
(if (= (logand s5-4 (minimap-flag bigmap)) (minimap-flag bigmap))
(format #t "bigmap ")
)
(if (= (logand s5-4 (minimap-flag fade-in)) (minimap-flag fade-in))
(format #t "fade-in ")
)
(if (= (logand s5-4 (minimap-flag racer)) (minimap-flag racer))
(format #t "racer ")
)
(if (= (logand s5-4 (minimap-flag task)) (minimap-flag task))
(format #t "task ")
)
(if (= (logand s5-4 (minimap-flag enemy)) (minimap-flag enemy))
(format #t "enemy ")
)
(if (= (logand s5-4 (minimap-flag clamp)) (minimap-flag clamp))
(format #t "clamp ")
)
(if (= (logand s5-4 (minimap-flag minimap)) (minimap-flag minimap))
(format #t "minimap ")
)
(if (= (logand s5-4 (minimap-flag flash)) (minimap-flag flash))
(format #t "flash ")
)
(if (= (logand s5-4 (minimap-flag task-graph)) (minimap-flag task-graph))
(format #t "task-graph ")
)
(if (= (logand s5-4 (minimap-flag trail)) (minimap-flag trail))
(format #t "trail ")
)
(if (= (logand s5-4 (minimap-flag frustum)) (minimap-flag frustum))
(format #t "frustum ")
)
(if (= (logand s5-4 (minimap-flag background)) (minimap-flag background))
(format #t "background ")
)
(if (= (logand s5-4 (minimap-flag goal)) (minimap-flag goal))
(format #t "goal ")
)
(if (= (logand s5-4 (minimap-flag fade-out)) (minimap-flag fade-out))
(format #t "fade-out ")
)
(if (= (logand s5-4 (minimap-flag city-only)) (minimap-flag city-only))
(format #t "city-only ")
)
)
(format #t ")~%")
(format #t "~1Tnode: ~D~%" (-> this node))
(format #t "~1Tedge-ry: ~f~%" (-> this edge-ry))
(format #t "~1Tlast-world-pos: ~`vector`P~%" (-> this last-world-pos))
(format #t "~1Tlast-relative-pos: ~`vector`P~%" (-> this last-relative-pos))
(label cfg-48)
this
)
;; definition of type engine-minimap
(deftype engine-minimap (engine-pers)
((alive-list connection-minimap :override)
(dead-list connection-minimap :override)
)
)
;; definition for method 3 of type engine-minimap
(defmethod inspect ((this engine-minimap))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this (-> this type))
(format #t "~1Tname: ~A~%" (-> this name))
(format #t "~1Tlength: ~D~%" (-> this length))
(format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
(format #t "~1Telement-type: ~A~%" (-> this element-type))
(format #t "~1Texecute-time: ~D~%" (-> this execute-time))
(format #t "~1Talive-list: #<connection-minimap @ #x~X>~%" (-> this alive-list))
(format #t "~1Tdead-list: #<connection-minimap @ #x~X>~%" (-> this dead-list))
(format #t "~1Tdata[0] @ #x~X~%" (-> this data))
(label cfg-4)
this
)
;; definition of type minimap-trail
(deftype minimap-trail (structure)
((used-by connection-minimap)
(search-id uint32)
(node-count int16)
(goal-node-id int32)
(node-path-dist float)
(last-updated uint64)
(cached-info trail-cached-search-info :inline)
(node-id uint16 64)
)
(:methods
(get-distance-with-path (_type_ vector vector) float)
(reset (_type_) none)
)
)
;; definition for method 3 of type minimap-trail
(defmethod inspect ((this minimap-trail))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'minimap-trail)
(format #t "~1Tused-by: ~`connection-minimap`P~%" (-> this used-by))
(format #t "~1Tsearch-id: ~D~%" (-> this search-id))
(format #t "~1Tnode-count: ~D~%" (-> this node-count))
(format #t "~1Tgoal-node-id: ~D~%" (-> this goal-node-id))
(format #t "~1Tnode-path-dist: ~f~%" (-> this node-path-dist))
(format #t "~1Tlast-updated: ~D~%" (-> this last-updated))
(format #t "~1Tcached-info: #<trail-cached-search-info @ #x~X>~%" (-> this cached-info))
(format #t "~1Tnode-id[64] @ #x~X~%" (-> this node-id))
(label cfg-4)
this
)
;; definition of type minimap-draw-work
(deftype minimap-draw-work (structure)
((buf dma-buffer)
(justify-right symbol)
(draw-pos vector4w :inline)
(mat matrix :inline)
(corner vector 4 :inline)
)
)
;; definition for method 3 of type minimap-draw-work
(defmethod inspect ((this minimap-draw-work))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'minimap-draw-work)
(format #t "~1Tbuf: ~A~%" (-> this buf))
(format #t "~1Tjustify-right: ~A~%" (-> this justify-right))
(format #t "~1Tdraw-pos: #<vector4w @ #x~X>~%" (-> this draw-pos))
(format #t "~1Tmat: #<matrix @ #x~X>~%" (-> this mat))
(format #t "~1Tcorner[4] @ #x~X~%" (-> this corner))
(label cfg-4)
this
)
;; definition of type minimap
(deftype minimap (structure)
((draw-tmpl dma-gif-packet :inline)
(draw2-tmpl dma-gif-packet :inline)
(draw3-tmpl dma-gif-packet :inline)
(draw4-tmpl dma-gif-packet :inline)
(sprite-tmpl dma-gif-packet :inline)
(adgif-tmpl dma-gif-packet :inline)
(color vector4w :inline)
(offset vector :inline)
(minimap-corner vector :inline)
(last-name string)
(last-tex basic)
(target-inv-scale float)
(map-bits uint64)
(level level)
(ctywide level)
(inv-scale float :overlay-at (-> offset data 1))
(fade float :overlay-at (-> offset data 3))
(engine engine-minimap)
(engine-key uint32)
(trail minimap-trail 6 :inline)
(race-tex texture)
(race-scale float)
(race-level level)
(sprite2-tmpl dma-gif-packet :inline)
(race-corner vector :inline)
(goal-time float)
(frustum-alpha float)
)
(:methods
(debug-draw (_type_) none)
(get-trail-for-connection (_type_ connection-minimap symbol) minimap-trail)
(get-icon-draw-pos (_type_ connection-minimap minimap-trail vector float vector) symbol)
(add-icon! (_type_ process uint int vector int) connection-minimap)
(free-trail-by-connection (_type_ connection-minimap) none)
(update-trails (_type_) none)
(draw-1 (_type_ dma-buffer vector4w symbol) none)
(draw-connection (_type_ minimap-draw-work connection-minimap) none)
(draw-frustum-1 (_type_ minimap-draw-work connection-minimap) none)
(draw-frustum-2 (_type_ minimap-draw-work connection-minimap) none)
(sub-draw-1-2 (_type_ minimap-draw-work) none)
(update! (_type_) symbol)
(sub-draw-1-1 (_type_ minimap-draw-work) none)
(set-color (_type_ vector) none)
(draw-racer-2 (_type_ minimap-draw-work connection-minimap) none)
(draw-sprite2 (_type_ dma-buffer vector4w symbol) none)
(set-race-texture (_type_ texture float level) none)
(draw-racer-1 (_type_ minimap-draw-work connection-minimap float float float) none)
(set-race-corner (_type_ float float) none)
)
)
;; definition for method 3 of type minimap
(defmethod inspect ((this minimap))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'minimap)
(format #t "~1Tdraw-tmpl: #<dma-gif-packet @ #x~X>~%" (-> this draw-tmpl))
(format #t "~1Tdraw2-tmpl: #<dma-gif-packet @ #x~X>~%" (-> this draw2-tmpl))
(format #t "~1Tdraw3-tmpl: #<dma-gif-packet @ #x~X>~%" (-> this draw3-tmpl))
(format #t "~1Tdraw4-tmpl: #<dma-gif-packet @ #x~X>~%" (-> this draw4-tmpl))
(format #t "~1Tsprite-tmpl: #<dma-gif-packet @ #x~X>~%" (-> this sprite-tmpl))
(format #t "~1Tadgif-tmpl: #<dma-gif-packet @ #x~X>~%" (-> this adgif-tmpl))
(format #t "~1Tcolor: #<vector4w @ #x~X>~%" (-> this color))
(format #t "~1Toffset: #<vector @ #x~X>~%" (-> this offset))
(format #t "~1Tminimap-corner: #<vector @ #x~X>~%" (-> this minimap-corner))
(format #t "~1Tlast-name: ~A~%" (-> this last-name))
(format #t "~1Tlast-tex: ~A~%" (-> this last-tex))
(format #t "~1Ttarget-inv-scale: ~f~%" (-> this target-inv-scale))
(format #t "~1Tmap-bits: ~D~%" (-> this map-bits))
(format #t "~1Tlevel: ~A~%" (-> this level))
(format #t "~1Tctywide: ~A~%" (-> this ctywide))
(format #t "~1Tinv-scale: ~f~%" (-> this offset y))
(format #t "~1Tfade: ~f~%" (-> this offset w))
(format #t "~1Tengine: ~A~%" (-> this engine))
(format #t "~1Tengine-key: ~D~%" (-> this engine-key))
(format #t "~1Ttrail[6] @ #x~X~%" (-> this trail))
(format #t "~1Trace-tex: ~A~%" (-> this race-tex))
(format #t "~1Trace-scale: ~f~%" (-> this race-scale))
(format #t "~1Trace-level: ~A~%" (-> this race-level))
(format #t "~1Tsprite2-tmpl: #<dma-gif-packet @ #x~X>~%" (-> this sprite2-tmpl))
(format #t "~1Trace-corner: #<vector @ #x~X>~%" (-> this race-corner))
(format #t "~1Tgoal-time: ~f~%" (-> this goal-time))
(format #t "~1Tfrustum-alpha: ~f~%" (-> this frustum-alpha))
(label cfg-4)
this
)
;; failed to figure out what this is:
0