mirror/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project synced 2026-08-13 04:10:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

decomp3: more headers (#3356)

Browse Source 
- `pov-camera-h`
- `sync-info-h`
- `trajectory-h`
- `collide-target-h` (`control-info` just padded out for now)
- `water-info-h`
- `process-drawable-h`
- `process-focusable`
- `focus`
- `effect-control-h`
- `process-taskable-h`
- `generic-obs-h`
- `target-h`
This commit is contained in:
Hat Kid
2024-02-01 23:58:10 +01:00
committed by GitHub
parent d67b441dac
commit 7e5541d793
38 changed files with 4763 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/decompiler/reference/jak3/decompiler-macros.gc
Generated Vendored
+10
View File
@@ -107,6 +107,16 @@
)
)
(defmacro ppointer->handle (pproc)
`(let ((the-process (the-as (pointer process) ,pproc)))
(new 'static 'handle :process the-process :pid (-> the-process 0 pid))
)
)
(defmacro process->handle (proc)
"convert a process to a handle. if proc is #f, returns a #f handle."
`(ppointer->handle (process->ppointer (the-as process ,proc)))
)
;; use a compile-time list to keep track of the type of an anonymous behavior.
(seval (define *defstate-type-stack* '()))
test/decompiler/reference/jak3/engine/anim/joint-h_REF.gc
Generated Vendored
+4 -4
View File
@@ -3,6 +3,8 @@
;; definition of type joint-control-channel
(deftype joint-control-channel (structure)
"A single animation channel that controls a number of joints.
Multiple channels are used to blend animations together."
((parent joint-control)
(frame-group art-joint-anim)
(frame-num float)
@@ -140,6 +142,7 @@
;; definition of type joint-control
(deftype joint-control (basic)
"Every [[process-drawable]] has a [[joint-control]] that handles all the animation channels."
((status joint-control-status)
(allocated-length uint8)
(active-channels uint8)
@@ -257,6 +260,7 @@
;; definition of type channel-upload-info
(deftype channel-upload-info (structure)
"Information about an upload of animation data to a single joint channel."
((fixed joint-anim-compressed-fixed)
(fixed-qwc int32)
(frame joint-anim-compressed-frame)
@@ -330,7 +334,3 @@
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/camera/pov-camera-h_REF.gc
Generated Vendored
+57
View File
@@ -0,0 +1,57 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type pov-camera
(deftype pov-camera (process-drawable)
((flags pov-camera-flags)
(debounce-start-time time-frame)
(notify-handle handle)
(anim-name string)
(command-list pair)
(mask-to-clear process-mask)
(music-volume-movie float)
(sfx-volume-movie float)
)
(:state-methods
pov-camera-abort
pov-camera-done-playing
pov-camera-playing
pov-camera-start-playing
pov-camera-startup
)
(:methods
(pov-camera-method-25 () none)
(pov-camera-method-26 () none)
(pov-camera-method-27 () none)
(pov-camera-method-28 () none)
(pov-camera-method-29 () none)
)
)
;; definition for method 3 of type pov-camera
(defmethod inspect ((this pov-camera))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 this)
)
(format #t "~2Tflags: ~D~%" (-> this flags))
(format #t "~2Tdebounce-start-time: ~D~%" (-> this debounce-start-time))
(format #t "~2Tnotify-handle: ~D~%" (-> this notify-handle))
(format #t "~2Tanim-name: ~A~%" (-> this anim-name))
(format #t "~2Tcommand-list: ~A~%" (-> this command-list))
(format #t "~2Tmask-to-clear: ~D~%" (-> this mask-to-clear))
(format #t "~2Tmusic-volume-movie: ~f~%" (-> this music-volume-movie))
(format #t "~2Tsfx-volume-movie: ~f~%" (-> this sfx-volume-movie))
(label cfg-4)
this
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/collide/collide-shape-h_REF.gc
Generated Vendored
+5 -5
View File
@@ -1438,9 +1438,9 @@ Most [[process-drawable]]s have a [[collide-shape]] that represents their root t
)
(format #t "[~8x] ~A~%" this (-> this type))
(format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
(format #t "~1Trot: ~`vector`P~%" (-> this rot))
(format #t "~1Trot: ~`vector`P~%" (-> this quat))
(format #t "~1Tscale: ~`vector`P~%" (-> this scale))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this rot))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
(format #t "~1Tpause-adjust-distance: (meters ~m)~%" (-> this pause-adjust-distance))
(format #t "~1Tnav-radius: (meters ~m)~%" (-> this nav-radius))
(format #t "~1Ttransv: ~`vector`P~%" (-> this transv))
@@ -1524,9 +1524,9 @@ Most [[process-drawable]]s have a [[collide-shape]] that represents their root t
)
(format #t "[~8x] ~A~%" this (-> this type))
(format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
(format #t "~1Trot: ~`vector`P~%" (-> this rot))
(format #t "~1Trot: ~`vector`P~%" (-> this quat))
(format #t "~1Tscale: ~`vector`P~%" (-> this scale))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this rot))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
(format #t "~1Tpause-adjust-distance: (meters ~m)~%" (-> this pause-adjust-distance))
(format #t "~1Tnav-radius: (meters ~m)~%" (-> this nav-radius))
(format #t "~1Ttransv: ~`vector`P~%" (-> this transv))
@@ -1667,7 +1667,7 @@ Most [[process-drawable]]s have a [[collide-shape]] that represents their root t
)
)
(set! (-> s5-0 trans w) 1.0)
(quaternion-identity! (the-as quaternion (-> s5-0 rot)))
(quaternion-identity! (-> s5-0 quat))
(vector-identity! (-> s5-0 scale))
(cond
((= arg1 (collide-list-enum hit-by-player))
test/decompiler/reference/jak3/engine/collide/collide-target-h_REF.gc
Generated Vendored
+15
View File
@@ -0,0 +1,15 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type control-info
(deftype control-info (collide-shape-moving)
((pad uint8 5944)
)
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/common-obs/generic-obs-h_REF.gc
Generated Vendored
+767
View File
@@ -0,0 +1,767 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type manipy
(deftype manipy (process-drawable)
((root collide-shape :override)
(new-trans-hook (function none))
(cur-trans-hook (function none))
(cur-event-hook (function none))
(new-joint-anim art-joint-anim)
(new-joint-anim-blend uint64)
(new-joint-anim-frame float)
(anim-mode symbol)
(cur-grab-handle handle)
(cur-target-handle handle)
(old-grab-pos vector :inline)
(joint joint-mod 4)
(new-post-hook (function none))
(cur-post-hook (function none))
(clone-copy-trans symbol)
(shadow-backup basic)
(draw? symbol)
(userdata uint64)
(prefix basic)
(shadow-volume-joint int32)
(speed float)
(user-uint64 uint64 4)
(options manipy-options)
)
(:state-methods
idle
)
)
;; definition for method 3 of type manipy
(defmethod inspect ((this manipy))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 this)
)
(format #t "~2Tnew-trans-hook: ~A~%" (-> this new-trans-hook))
(format #t "~2Tcur-trans-hook: ~A~%" (-> this cur-trans-hook))
(format #t "~2Tcur-event-hook: ~A~%" (-> this cur-event-hook))
(format #t "~2Tnew-joint-anim: ~A~%" (-> this new-joint-anim))
(format #t "~2Tnew-joint-anim-blend: ~D~%" (-> this new-joint-anim-blend))
(format #t "~2Tnew-joint-anim-frame: ~f~%" (-> this new-joint-anim-frame))
(format #t "~2Tanim-mode: ~A~%" (-> this anim-mode))
(format #t "~2Tcur-grab-handle: ~D~%" (-> this cur-grab-handle))
(format #t "~2Tcur-target-handle: ~D~%" (-> this cur-target-handle))
(format #t "~2Told-grab-pos: ~`vector`P~%" (-> this old-grab-pos))
(format #t "~2Tjoint[4] @ #x~X~%" (-> this joint))
(format #t "~2Tnew-post-hook: ~A~%" (-> this new-post-hook))
(format #t "~2Tcur-post-hook: ~A~%" (-> this cur-post-hook))
(format #t "~2Tclone-copy-trans: ~A~%" (-> this clone-copy-trans))
(format #t "~2Tshadow-backup: ~A~%" (-> this shadow-backup))
(format #t "~2Tdraw?: ~A~%" (-> this draw?))
(format #t "~2Tuserdata: ~A~%" (-> this userdata))
(format #t "~2Tprefix: ~A~%" (-> this prefix))
(format #t "~2Tshadow-volume-joint: ~D~%" (-> this shadow-volume-joint))
(format #t "~2Tspeed: ~f~%" (-> this speed))
(format #t "~2Tuser-uint64[4] @ #x~X~%" (-> this user-uint64))
(format #t "~2Toptions: ~D~%" (-> this options))
(label cfg-4)
this
)
;; definition of type part-spawner
(deftype part-spawner (process)
"A process that spawns a specified particle group."
((root trsqv)
(part sparticle-launch-control)
(path basic)
(sound ambient-sound)
(sound-extra basic)
(mode (pointer sparticle-launch-group))
(enable symbol)
(path-pos float)
(path-speed float)
(last-velocity vector :inline)
(radius meters)
(world-sphere sphere :inline)
)
(:state-methods
active
)
(:methods
(part-spawner-method-15 () none)
)
)
;; definition for method 3 of type part-spawner
(defmethod inspect ((this part-spawner))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process inspect)))
(t9-0 this)
)
(format #t "~2Troot: ~A~%" (-> this root))
(format #t "~2Tpart: ~A~%" (-> this part))
(format #t "~2Tpath: ~A~%" (-> this path))
(format #t "~2Tsound: ~A~%" (-> this sound))
(format #t "~2Tsound-extra: ~A~%" (-> this sound-extra))
(format #t "~2Tmode: #x~X~%" (-> this mode))
(format #t "~2Tenable: ~A~%" (-> this enable))
(format #t "~2Tpath-pos: ~f~%" (-> this path-pos))
(format #t "~2Tpath-speed: ~f~%" (-> this path-speed))
(format #t "~2Tlast-velocity: #<vector @ #x~X>~%" (-> this last-velocity))
(format #t "~2Tradius: (meters ~m)~%" (-> this radius))
(format #t "~2Tworld-sphere: #<sphere @ #x~X>~%" (-> this world-sphere))
(label cfg-4)
this
)
;; definition of type part-tracker
(deftype part-tracker (process)
((root trsqv)
(mat matrix :inline)
(offset vector :inline)
(userdata uint64)
(user-time time-frame 2)
(user-vector vector :inline)
(user-handle uint32 2 :offset 288)
(part sparticle-launch-control)
(callback (function part-tracker vector))
(linger-callback (function part-tracker vector))
(duration time-frame)
(linger-duration time-frame)
(state-time time-frame)
(target handle)
(target-joint int32)
)
(:methods
(part-tracker-method-14 () none)
(part-tracker-method-15 () none)
(part-tracker-method-16 () none)
(part-tracker-method-17 () none)
)
)
;; definition for method 3 of type part-tracker
(defmethod inspect ((this part-tracker))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process inspect)))
(t9-0 this)
)
(format #t "~2Troot: ~A~%" (-> this root))
(format #t "~2Tmat: #<matrix @ #x~X>~%" (-> this mat))
(format #t "~2Toffset: ~`vector`P~%" (-> this offset))
(format #t "~2Tuserdata: ~A~%" (-> this userdata))
(format #t "~2Tuser-time[2] @ #x~X~%" (-> this user-time))
(format #t "~2Tuser-vector: ~`vector`P~%" (-> this user-vector))
(format #t "~2Tuser-handle[2] @ #x~X~%" (-> this user-handle))
(format #t "~2Tpart: ~A~%" (-> this part))
(format #t "~2Tcallback: ~A~%" (-> this callback))
(format #t "~2Tlinger-callback: ~A~%" (-> this linger-callback))
(format #t "~2Tduration: ~D~%" (-> this duration))
(format #t "~2Tlinger-duration: ~D~%" (-> this linger-duration))
(format #t "~2Tstate-time: ~D~%" (-> this state-time))
(format #t "~2Ttarget: ~D~%" (-> this target))
(format #t "~2Ttarget-joint: ~D~%" (-> this target-joint))
(label cfg-4)
this
)
;; definition of type part-tracker-init-params
(deftype part-tracker-init-params (structure)
((userdata uint64)
(duration time-frame)
(group sparticle-launch-group)
(callback (function part-tracker vector))
(target basic)
(mat-joint basic)
)
)
;; definition for method 3 of type part-tracker-init-params
(defmethod inspect ((this part-tracker-init-params))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'part-tracker-init-params)
(format #t "~1Tuserdata: ~A~%" (-> this userdata))
(format #t "~1Tduration: ~D~%" (-> this duration))
(format #t "~1Tgroup: ~A~%" (-> this group))
(format #t "~1Tcallback: ~A~%" (-> this callback))
(format #t "~1Ttarget: ~A~%" (-> this target))
(format #t "~1Tmat-joint: ~A~%" (-> this mat-joint))
(label cfg-4)
this
)
;; definition of type part-tracker-subsampler-init-params
(deftype part-tracker-subsampler-init-params (structure)
((userdata uint64)
(duration time-frame)
(group sparticle-launch-group)
(callback (function part-tracker vector))
(target basic)
(mat-joint basic)
(subsample-num float)
)
)
;; definition for method 3 of type part-tracker-subsampler-init-params
(defmethod inspect ((this part-tracker-subsampler-init-params))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'part-tracker-subsampler-init-params)
(format #t "~1Tuserdata: ~A~%" (-> this userdata))
(format #t "~1Tduration: ~D~%" (-> this duration))
(format #t "~1Tgroup: ~A~%" (-> this group))
(format #t "~1Tcallback: ~A~%" (-> this callback))
(format #t "~1Ttarget: ~A~%" (-> this target))
(format #t "~1Tmat-joint: ~A~%" (-> this mat-joint))
(format #t "~1Tsubsample-num: ~f~%" (-> this subsample-num))
(label cfg-4)
this
)
;; definition of type part-tracker-subsampler
(deftype part-tracker-subsampler (part-tracker)
((subsampler basic)
)
)
;; definition for method 3 of type part-tracker-subsampler
(defmethod inspect ((this part-tracker-subsampler))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type part-tracker inspect)))
(t9-0 this)
)
(format #t "~2Tsubsampler: ~A~%" (-> this subsampler))
(label cfg-4)
this
)
;; definition of type lightning-tracker
(deftype lightning-tracker (process)
((root trsqv)
(lightning lightning-control)
(callback (function lightning-tracker none))
(duration time-frame)
(start-time time-frame)
(offset0 vector :inline)
(offset1 vector :inline)
(target0 handle)
(target1 handle)
(target-joint0 int32)
(target-joint1 int32)
(sound sound-id)
(userdata uint64)
(user-time time-frame 2)
(user-vector vector :inline)
(user-handle handle 2 :offset 288)
)
(:methods
(lightning-tracker-method-14 () none)
(lightning-tracker-method-15 () none)
(lightning-tracker-method-16 () none)
)
)
;; definition for method 3 of type lightning-tracker
(defmethod inspect ((this lightning-tracker))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process inspect)))
(t9-0 this)
)
(format #t "~2Troot: ~A~%" (-> this root))
(format #t "~2Tlightning: ~A~%" (-> this lightning))
(format #t "~2Tcallback: ~A~%" (-> this callback))
(format #t "~2Tduration: ~D~%" (-> this duration))
(format #t "~2Tstart-time: ~D~%" (-> this start-time))
(format #t "~2Toffset0: ~`vector`P~%" (-> this offset0))
(format #t "~2Toffset1: ~`vector`P~%" (-> this offset1))
(format #t "~2Ttarget0: ~D~%" (-> this target0))
(format #t "~2Ttarget1: ~D~%" (-> this target1))
(format #t "~2Ttarget-joint0: ~D~%" (-> this target-joint0))
(format #t "~2Ttarget-joint1: ~D~%" (-> this target-joint1))
(format #t "~2Tsound: ~D~%" (-> this sound))
(format #t "~2Tuserdata: ~A~%" (-> this userdata))
(format #t "~2Tuser-time[2] @ #x~X~%" (-> this user-time))
(format #t "~2Tuser-vector: ~`vector`P~%" (-> this user-vector))
(format #t "~2Tuser-handle[2] @ #x~X~%" (-> this user-handle))
(label cfg-4)
this
)
;; definition of type touch-tracker
(deftype touch-tracker (process-drawable)
((duration time-frame)
(target handle)
(event symbol)
(run-function (function object))
(callback (function touch-tracker none))
(event-mode basic)
)
(:methods
(touch-tracker-method-20 () none)
)
)
;; definition for method 3 of type touch-tracker
(defmethod inspect ((this touch-tracker))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 this)
)
(format #t "~2Tduration: ~D~%" (-> this duration))
(format #t "~2Ttarget: ~D~%" (-> this target))
(format #t "~2Tevent: ~A~%" (-> this event))
(format #t "~2Trun-function: ~A~%" (-> this run-function))
(format #t "~2Tcallback: ~A~%" (-> this callback))
(format #t "~2Tevent-mode: ~A~%" (-> this event-mode))
(label cfg-4)
this
)
;; definition of type swingpole
(deftype swingpole (process-drawable)
((edge-length meters)
(path-pos float)
(joint-track int32)
(speed meters)
(dir vector :inline)
(sync sync-eased :inline)
)
(:methods
(swingpole-method-20 () none)
(swingpole-method-21 () none)
(swingpole-method-22 () none)
(swingpole-method-23 () none)
(swingpole-method-24 () none)
)
)
;; definition for method 3 of type swingpole
(defmethod inspect ((this swingpole))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 this)
)
(format #t "~2Tedge-length: (meters ~m)~%" (-> this edge-length))
(format #t "~2Tpath-pos: ~f~%" (-> this path-pos))
(format #t "~2Tjoint-track: ~D~%" (-> this joint-track))
(format #t "~2Tspeed: (meters ~m)~%" (-> this speed))
(format #t "~2Tdir: ~`vector`P~%" (-> this dir))
(format #t "~2Tsync: #<sync-eased @ #x~X>~%" (-> this sync))
(label cfg-4)
this
)
;; definition of type gui-query
(deftype gui-query (structure)
((x-position int32)
(y-position int32)
(message string)
(decision symbol)
(only-allow-cancel symbol)
(no-msg string)
(message-space int32)
)
(:methods
(gui-query-method-9 () none)
(gui-query-method-10 () none)
)
)
;; definition for method 3 of type gui-query
(defmethod inspect ((this gui-query))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'gui-query)
(format #t "~1Tx-position: ~D~%" (-> this x-position))
(format #t "~1Ty-position: ~D~%" (-> this y-position))
(format #t "~1Tmessage: ~A~%" (-> this message))
(format #t "~1Tdecision: ~A~%" (-> this decision))
(format #t "~1Tonly-allow-cancel: ~A~%" (-> this only-allow-cancel))
(format #t "~1Tno-msg: ~A~%" (-> this no-msg))
(format #t "~1Tmessage-space: ~D~%" (-> this message-space))
(label cfg-4)
this
)
;; definition of type othercam
(deftype othercam (process)
((hand handle)
(old-global-mask process-mask)
(mask-to-clear process-mask)
(cam-joint-index int32)
(old-pos vector :inline)
(old-mat-z vector :inline)
(had-valid-frame symbol)
(border-value basic)
(die? symbol)
(survive-anim-end? symbol)
(spooling? symbol)
(fov float)
)
(:states
othercam-running
)
)
;; definition for method 3 of type othercam
(defmethod inspect ((this othercam))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process inspect)))
(t9-0 this)
)
(format #t "~2Thand: ~D~%" (-> this hand))
(format #t "~2Told-global-mask: ~D~%" (-> this old-global-mask))
(format #t "~2Tmask-to-clear: ~D~%" (-> this mask-to-clear))
(format #t "~2Tcam-joint-index: ~D~%" (-> this cam-joint-index))
(format #t "~2Told-pos: #<vector @ #x~X>~%" (-> this old-pos))
(format #t "~2Told-mat-z: #<vector @ #x~X>~%" (-> this old-mat-z))
(format #t "~2Thad-valid-frame: ~A~%" (-> this had-valid-frame))
(format #t "~2Tborder-value: ~A~%" (-> this border-value))
(format #t "~2Tdie?: ~A~%" (-> this die?))
(format #t "~2Tsurvive-anim-end?: ~A~%" (-> this survive-anim-end?))
(format #t "~2Tspooling?: ~A~%" (-> this spooling?))
(format #t "~2Tfov: ~f~%" (-> this fov))
(label cfg-4)
this
)
;; definition of type explosion-init-params
(deftype explosion-init-params (structure)
((spawn-point vector :inline)
(spawn-quat quaternion :inline)
(radius float)
(scale float)
(group sparticle-launch-group)
(collide-with collide-spec)
(damage float)
(damage-scale float)
(vehicle-damage-factor float)
(vehicle-impulse-factor float)
(ignore-proc uint64)
)
)
;; definition for method 3 of type explosion-init-params
(defmethod inspect ((this explosion-init-params))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'explosion-init-params)
(format #t "~1Tspawn-point: #<vector @ #x~X>~%" (-> this spawn-point))
(format #t "~1Tspawn-quat: #<quaternion @ #x~X>~%" (-> this spawn-quat))
(format #t "~1Tradius: ~f~%" (-> this radius))
(format #t "~1Tscale: ~f~%" (-> this scale))
(format #t "~1Tgroup: ~A~%" (-> this group))
(format #t "~1Tcollide-with: ~D~%" (-> this collide-with))
(format #t "~1Tdamage: ~f~%" (-> this damage))
(format #t "~1Tdamage-scale: ~f~%" (-> this damage-scale))
(format #t "~1Tvehicle-damage-factor: ~f~%" (-> this vehicle-damage-factor))
(format #t "~1Tvehicle-impulse-factor: ~f~%" (-> this vehicle-impulse-factor))
(format #t "~1Tignore-proc: ~D~%" (-> this ignore-proc))
(label cfg-4)
this
)
;; definition of type explosion
(deftype explosion (process-drawable)
((start-time time-frame)
(duration uint32)
(linger-duration uint32)
(attack-id uint32)
(mat matrix :inline)
(params explosion-init-params :inline)
)
(:methods
(explosion-method-20 () none)
(explosion-method-21 () none)
(explosion-method-22 () none)
)
)
;; definition for method 3 of type explosion
(defmethod inspect ((this explosion))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 this)
)
(format #t "~2Tstart-time: ~D~%" (-> this start-time))
(format #t "~2Tduration: ~D~%" (-> this duration))
(format #t "~2Tlinger-duration: ~D~%" (-> this linger-duration))
(format #t "~2Tattack-id: ~D~%" (-> this attack-id))
(format #t "~2Tmat: #<matrix @ #x~X>~%" (-> this mat))
(format #t "~2Tparams: #<explosion-init-params @ #x~X>~%" (-> this params))
(label cfg-4)
this
)
;; definition of type process-hidden
(deftype process-hidden (process)
()
(:state-methods
die
)
)
;; definition for method 3 of type process-hidden
(defmethod inspect ((this process-hidden))
(when (not this)
(set! this this)
(goto cfg-68)
)
(format #t "[~8x] ~A~%" this (-> this type))
(format #t "~1Tname: ~A~%" (-> this name))
(format #t "~1Tmask: #x~X : (process-mask " (-> this mask))
(let ((s5-0 (-> this mask)))
(if (= (logand s5-0 (process-mask process-tree)) (process-mask process-tree))
(format #t "process-tree ")
)
(if (= (logand s5-0 (process-mask target)) (process-mask target))
(format #t "target ")
)
(if (= (logand (process-mask collectable) s5-0) (process-mask collectable))
(format #t "collectable ")
)
(if (= (logand (process-mask projectile) s5-0) (process-mask projectile))
(format #t "projectile ")
)
(if (= (logand s5-0 (process-mask sleep-code)) (process-mask sleep-code))
(format #t "sleep-code ")
)
(if (= (logand s5-0 (process-mask actor-pause)) (process-mask actor-pause))
(format #t "actor-pause ")
)
(if (= (logand (process-mask metalhead) s5-0) (shl #x8000 16))
(format #t "metalhead ")
)
(if (= (logand (process-mask bot) s5-0) (process-mask bot))
(format #t "bot ")
)
(if (= (logand (process-mask vehicle) s5-0) (process-mask vehicle))
(format #t "vehicle ")
)
(if (= (logand (process-mask enemy) s5-0) (process-mask enemy))
(format #t "enemy ")
)
(if (= (logand (process-mask entity) s5-0) (process-mask entity))
(format #t "entity ")
)
(if (= (logand s5-0 (process-mask heap-shrunk)) (process-mask heap-shrunk))
(format #t "heap-shrunk ")
)
(if (= (logand (process-mask sidekick) s5-0) (process-mask sidekick))
(format #t "sidekick ")
)
(if (= (logand s5-0 (process-mask going)) (process-mask going))
(format #t "going ")
)
(if (= (logand s5-0 (process-mask execute)) (process-mask execute))
(format #t "execute ")
)
(if (= (logand (process-mask civilian) s5-0) (process-mask civilian))
(format #t "civilian ")
)
(if (= (logand (process-mask death) s5-0) (process-mask death))
(format #t "death ")
)
(if (= (logand (process-mask guard) s5-0) (process-mask guard))
(format #t "guard ")
)
(if (= (logand s5-0 (process-mask no-kill)) (process-mask no-kill))
(format #t "no-kill ")
)
(if (= (logand (process-mask kg-robot) s5-0) (process-mask kg-robot))
(format #t "kg-robot ")
)
(if (= (logand (process-mask platform) s5-0) (process-mask platform))
(format #t "platform ")
)
(if (= (logand s5-0 (process-mask freeze)) (process-mask freeze))
(format #t "freeze ")
)
(if (= (logand s5-0 (process-mask sleep)) (process-mask sleep))
(format #t "sleep ")
)
(if (= (logand s5-0 (process-mask progress)) (process-mask progress))
(format #t "progress ")
)
(if (= (logand s5-0 (process-mask menu)) (process-mask menu))
(format #t "menu ")
)
(if (= (logand (process-mask camera) s5-0) (process-mask camera))
(format #t "camera ")
)
(if (= (logand (process-mask ambient) s5-0) (process-mask ambient))
(format #t "ambient ")
)
(if (= (logand s5-0 (process-mask dark-effect)) (process-mask dark-effect))
(format #t "dark-effect ")
)
(if (= (logand (process-mask crate) s5-0) (process-mask crate))
(format #t "crate ")
)
(if (= (logand s5-0 (process-mask kernel-run)) (process-mask kernel-run))
(format #t "kernel-run ")
)
(if (= (logand s5-0 (process-mask movie)) (process-mask movie))
(format #t "movie ")
)
(if (= (logand s5-0 (process-mask pause)) (process-mask pause))
(format #t "pause ")
)
)
(format #t ")~%")
(format #t "~1Tclock: ~A~%" (-> this clock))
(format #t "~1Tparent: #x~X~%" (-> this parent))
(format #t "~1Tbrother: #x~X~%" (-> this brother))
(format #t "~1Tchild: #x~X~%" (-> this child))
(format #t "~1Tppointer: #x~X~%" (-> this ppointer))
(format #t "~1Tself: ~A~%" (-> this self))
(format #t "~1Tpool: ~A~%" (-> this pool))
(format #t "~1Tstatus: ~A~%" (-> this status))
(format #t "~1Tpid: ~D~%" (-> this pid))
(format #t "~1Tmain-thread: ~A~%" (-> this main-thread))
(format #t "~1Ttop-thread: ~A~%" (-> this top-thread))
(format #t "~1Tentity: ~A~%" (-> this entity))
(format #t "~1Tlevel: ~A~%" (-> this level))
(format #t "~1Tstate: ~A~%" (-> this state))
(format #t "~1Tprev-state: ~A~%" (-> this prev-state))
(format #t "~1Tnext-state: ~A~%" (-> this next-state))
(format #t "~1Tstate-stack: ~A~%" (-> this state-stack))
(format #t "~1Ttrans-hook: ~A~%" (-> this trans-hook))
(format #t "~1Tpost-hook: ~A~%" (-> this post-hook))
(format #t "~1Tevent-hook: ~A~%" (-> this event-hook))
(format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
(format #t "~1Theap-base: #x~X~%" (-> this heap-base))
(format #t "~1Theap-top: #x~X~%" (-> this heap-top))
(format #t "~1Theap-cur: #x~X~%" (-> this heap-cur))
(format #t "~1Tstack-frame-top: ~A~%" (-> this stack-frame-top))
(format #t "~1Theap: #<kheap @ #x~X>~%" (&-> this heap-base))
(format #t "~1Tconnection-list: ~`connectable`P~%" (-> this connection-list))
(format #t "~1Tstack[0] @ #x~X~%" (-> this stack))
(label cfg-68)
this
)
;; definition of type simple-prim
(deftype simple-prim (process-drawable)
((strip prim-strip)
)
(:methods
(simple-prim-method-20 () none)
(simple-prim-method-21 () none)
(simple-prim-method-22 () none)
(simple-prim-method-23 () none)
(simple-prim-method-24 () none)
(simple-prim-method-25 () none)
)
)
;; definition for method 3 of type simple-prim
(defmethod inspect ((this simple-prim))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 this)
)
(format #t "~2Tstrip: ~A~%" (-> this strip))
(label cfg-4)
this
)
;; definition for symbol *simple-prim-additive*, type int
(define *simple-prim-additive* 72)
;; definition for symbol *simple-prim-alpha-blend*, type int
(define *simple-prim-alpha-blend* 68)
;; definition for symbol *simple-prim-subtractive*, type int
(define *simple-prim-subtractive* 66)
;; definition of type task-arrow-params
(deftype task-arrow-params (structure)
((flags task-arrow-flags)
(map-icon uint16)
(pos vector :inline)
(quat quaternion :inline)
)
)
;; definition for method 3 of type task-arrow-params
(defmethod inspect ((this task-arrow-params))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'task-arrow-params)
(format #t "~1Tflags: ~D~%" (-> this flags))
(format #t "~1Tmap-icon: ~D~%" (-> this map-icon))
(format #t "~1Tpos: #<vector @ #x~X>~%" (-> this pos))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
(label cfg-4)
this
)
;; definition of type external-camera-controller
(deftype external-camera-controller (process)
((pause-time time-frame)
(blur symbol)
)
(:methods
(external-camera-controller-method-14 () none)
)
)
;; definition for method 3 of type external-camera-controller
(defmethod inspect ((this external-camera-controller))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process inspect)))
(t9-0 this)
)
(format #t "~2Tpause-time: ~D~%" (-> this pause-time))
(format #t "~2Tblur: ~A~%" (-> this blur))
(label cfg-4)
this
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/common-obs/water-info-h_REF.gc
Generated Vendored
+261
View File
@@ -0,0 +1,261 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type water-info
(deftype water-info (structure)
((trans vector :inline)
(normal vector :inline)
(base-height meters)
(depth meters)
(handle handle)
(flags water-flag)
(prim drawable-region-prim)
(extra-flags uint32)
)
)
;; definition for method 3 of type water-info
(defmethod inspect ((this water-info))
(when (not this)
(set! this this)
(goto cfg-68)
)
(format #t "[~8x] ~A~%" this 'water-info)
(format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
(format #t "~1Tnormal: ~`vector`P~%" (-> this normal))
(format #t "~1Tbase-height: (meters ~m)~%" (-> this base-height))
(format #t "~1Tdepth: (meters ~m)~%" (-> this depth))
(format #t "~1Thandle: ~D~%" (-> this handle))
(format #t "~1Tflags: #x~X : (water-flag " (-> this flags))
(let ((s5-0 (-> this flags)))
(if (= (logand s5-0 (water-flag active)) (water-flag active))
(format #t "active ")
)
(if (= (logand s5-0 (water-flag deadly)) (water-flag deadly))
(format #t "deadly ")
)
(if (= (logand (water-flag touch-water-good) s5-0) (shl #x8000 16))
(format #t "touch-water-good ")
)
(if (= (logand s5-0 (water-flag lava)) (water-flag lava))
(format #t "lava ")
)
(if (= (logand (water-flag jump-out) s5-0) (water-flag jump-out))
(format #t "jump-out ")
)
(if (= (logand (water-flag head-under-water) s5-0) (water-flag head-under-water))
(format #t "head-under-water ")
)
(if (= (logand s5-0 (water-flag under-water)) (water-flag under-water))
(format #t "under-water ")
)
(if (= (logand s5-0 (water-flag swamp)) (water-flag swamp))
(format #t "swamp ")
)
(if (= (logand s5-0 (water-flag dark-eco)) (water-flag dark-eco))
(format #t "dark-eco ")
)
(if (= (logand (water-flag part-water) s5-0) (water-flag part-water))
(format #t "part-water ")
)
(if (= (logand (water-flag break-surface) s5-0) (water-flag break-surface))
(format #t "break-surface ")
)
(if (= (logand (water-flag over-water) s5-0) (water-flag over-water))
(format #t "over-water ")
)
(if (= (logand s5-0 (water-flag use-ocean)) (water-flag use-ocean))
(format #t "use-ocean ")
)
(if (= (logand s5-0 (water-flag flow)) (water-flag flow))
(format #t "flow ")
)
(if (= (logand (water-flag wading) s5-0) (water-flag wading))
(format #t "wading ")
)
(if (= (logand (water-flag part-rings) s5-0) (water-flag part-rings))
(format #t "part-rings ")
)
(if (= (logand (water-flag part-drip) s5-0) (water-flag part-drip))
(format #t "part-drip ")
)
(if (= (logand (water-flag part-splash) s5-0) (water-flag part-splash))
(format #t "part-splash ")
)
(if (= (logand s5-0 (water-flag swim-ground)) (water-flag swim-ground))
(format #t "swim-ground ")
)
(if (= (logand s5-0 (water-flag tar)) (water-flag tar))
(format #t "tar ")
)
(if (= (logand (water-flag swimming) s5-0) (water-flag swimming))
(format #t "swimming ")
)
(if (= (logand s5-0 (water-flag mud)) (water-flag mud))
(format #t "mud ")
)
(if (= (logand (water-flag event) s5-0) (water-flag event))
(format #t "event ")
)
(if (= (logand (water-flag bouncing) s5-0) (water-flag bouncing))
(format #t "bouncing ")
)
(if (= (logand s5-0 (water-flag use-water-anim)) (water-flag use-water-anim))
(format #t "use-water-anim ")
)
(if (= (logand (water-flag spawn-drip) s5-0) (water-flag spawn-drip))
(format #t "spawn-drip ")
)
(if (= (logand s5-0 (water-flag can-swim)) (water-flag can-swim))
(format #t "can-swim ")
)
(if (= (logand (water-flag touch-water) s5-0) (water-flag touch-water))
(format #t "touch-water ")
)
(if (= (logand s5-0 (water-flag no-grab-sound)) (water-flag no-grab-sound))
(format #t "no-grab-ground ")
)
(if (= (logand s5-0 (water-flag can-wade)) (water-flag can-wade))
(format #t "can-wade ")
)
(if (= (logand (water-flag find-water) s5-0) (water-flag find-water))
(format #t "find-water ")
)
(if (= (logand s5-0 (water-flag can-ground)) (water-flag can-ground))
(format #t "can-ground ")
)
)
(format #t ")~%")
(format #t "~1Tprim: ~A~%" (-> this prim))
(format #t "~1Textra-flags: ~D~%" (-> this extra-flags))
(label cfg-68)
this
)
;; definition of type water-sphere
(deftype water-sphere (structure)
((sphere sphere :inline)
(flags water-flag)
(user0 int32)
)
)
;; definition for method 3 of type water-sphere
(defmethod inspect ((this water-sphere))
(when (not this)
(set! this this)
(goto cfg-68)
)
(format #t "[~8x] ~A~%" this 'water-sphere)
(format #t "~1Tsphere: #<sphere @ #x~X>~%" (-> this sphere))
(format #t "~1Tflags: #x~X : (water-flag " (-> this flags))
(let ((s5-0 (-> this flags)))
(if (= (logand s5-0 (water-flag active)) (water-flag active))
(format #t "active ")
)
(if (= (logand s5-0 (water-flag deadly)) (water-flag deadly))
(format #t "deadly ")
)
(if (= (logand (water-flag touch-water-good) s5-0) (shl #x8000 16))
(format #t "touch-water-good ")
)
(if (= (logand s5-0 (water-flag lava)) (water-flag lava))
(format #t "lava ")
)
(if (= (logand (water-flag jump-out) s5-0) (water-flag jump-out))
(format #t "jump-out ")
)
(if (= (logand (water-flag head-under-water) s5-0) (water-flag head-under-water))
(format #t "head-under-water ")
)
(if (= (logand s5-0 (water-flag under-water)) (water-flag under-water))
(format #t "under-water ")
)
(if (= (logand s5-0 (water-flag swamp)) (water-flag swamp))
(format #t "swamp ")
)
(if (= (logand s5-0 (water-flag dark-eco)) (water-flag dark-eco))
(format #t "dark-eco ")
)
(if (= (logand (water-flag part-water) s5-0) (water-flag part-water))
(format #t "part-water ")
)
(if (= (logand (water-flag break-surface) s5-0) (water-flag break-surface))
(format #t "break-surface ")
)
(if (= (logand (water-flag over-water) s5-0) (water-flag over-water))
(format #t "over-water ")
)
(if (= (logand s5-0 (water-flag use-ocean)) (water-flag use-ocean))
(format #t "use-ocean ")
)
(if (= (logand s5-0 (water-flag flow)) (water-flag flow))
(format #t "flow ")
)
(if (= (logand (water-flag wading) s5-0) (water-flag wading))
(format #t "wading ")
)
(if (= (logand (water-flag part-rings) s5-0) (water-flag part-rings))
(format #t "part-rings ")
)
(if (= (logand (water-flag part-drip) s5-0) (water-flag part-drip))
(format #t "part-drip ")
)
(if (= (logand (water-flag part-splash) s5-0) (water-flag part-splash))
(format #t "part-splash ")
)
(if (= (logand s5-0 (water-flag swim-ground)) (water-flag swim-ground))
(format #t "swim-ground ")
)
(if (= (logand s5-0 (water-flag tar)) (water-flag tar))
(format #t "tar ")
)
(if (= (logand (water-flag swimming) s5-0) (water-flag swimming))
(format #t "swimming ")
)
(if (= (logand s5-0 (water-flag mud)) (water-flag mud))
(format #t "mud ")
)
(if (= (logand (water-flag event) s5-0) (water-flag event))
(format #t "event ")
)
(if (= (logand (water-flag bouncing) s5-0) (water-flag bouncing))
(format #t "bouncing ")
)
(if (= (logand s5-0 (water-flag use-water-anim)) (water-flag use-water-anim))
(format #t "use-water-anim ")
)
(if (= (logand (water-flag spawn-drip) s5-0) (water-flag spawn-drip))
(format #t "spawn-drip ")
)
(if (= (logand s5-0 (water-flag can-swim)) (water-flag can-swim))
(format #t "can-swim ")
)
(if (= (logand (water-flag touch-water) s5-0) (water-flag touch-water))
(format #t "touch-water ")
)
(if (= (logand s5-0 (water-flag no-grab-sound)) (water-flag no-grab-sound))
(format #t "no-grab-ground ")
)
(if (= (logand s5-0 (water-flag can-wade)) (water-flag can-wade))
(format #t "can-wade ")
)
(if (= (logand (water-flag find-water) s5-0) (water-flag find-water))
(format #t "find-water ")
)
(if (= (logand s5-0 (water-flag can-ground)) (water-flag can-ground))
(format #t "can-ground ")
)
)
(format #t ")~%")
(format #t "~1Tuser0: ~D~%" (-> this user0))
(label cfg-68)
this
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/game/effect-control-h_REF.gc
Generated Vendored
+75
View File
@@ -0,0 +1,75 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type effect-control
(deftype effect-control (basic)
"An effect such as a particle with sound effects that plays during an animation."
((process process-drawable)
(flags effect-control-flag)
(last-frame-group art-joint-anim)
(last-frame-num float)
(channel-offset int32)
(res res-lump)
(name (pointer res-tag))
(param uint32)
)
(:methods
(new (symbol type process-drawable) _type_)
(effect-control-method-9 () none)
(effect-control-method-10 () none)
(effect-control-method-11 () none)
(effect-control-method-12 () none)
(set-channel-offset! (_type_ int) none)
(effect-control-method-14 () none)
)
)
;; definition for method 3 of type effect-control
(defmethod inspect ((this effect-control))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this (-> this type))
(format #t "~1Tprocess: ~A~%" (-> this process))
(format #t "~1Tflags: #x~X~%" (-> this flags))
(format #t "~1Tlast-frame-group: ~A~%" (-> this last-frame-group))
(format #t "~1Tlast-frame-num: ~f~%" (-> this last-frame-num))
(format #t "~1Tchannel-offset: ~D~%" (-> this channel-offset))
(format #t "~1Tres: ~A~%" (-> this res))
(format #t "~1Tname: #x~X~%" (-> this name))
(format #t "~1Tparam: #x~X~%" (-> this param))
(label cfg-4)
this
)
;; definition for method 0 of type effect-control
(defmethod new effect-control ((allocation symbol) (type-to-make type) (proc process-drawable))
(cond
((res-lump-struct (-> proc draw jgeo extra) 'effect-name structure)
(let ((v0-1 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
(set! (-> v0-1 process) proc)
(set! (-> v0-1 last-frame-group) #f)
v0-1
)
)
(else
(the-as effect-control #f)
)
)
)
;; definition for method 13 of type effect-control
;; WARN: Return type mismatch int vs none.
(defmethod set-channel-offset! ((this effect-control) (offset int))
(set! (-> this channel-offset) offset)
0
(none)
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/game/game-h_REF.gc
Generated Vendored
+2 -4
View File
@@ -292,6 +292,7 @@ to have a type with a large number of slots which can be turned into real method
;; definition of type attack-dir-info
(deftype attack-dir-info (structure)
"Information about the position/direction of an attack."
((dir vector :inline)
(xz-dir vector :inline)
(attacker-velocity vector :inline)
@@ -316,6 +317,7 @@ to have a type with a large number of slots which can be turned into real method
;; definition of type attack-info
(deftype attack-info (structure)
"Information about an incoming attack."
((trans vector :inline)
(vector vector :inline)
(attacker-velocity vector :inline)
@@ -489,7 +491,3 @@ to have a type with a large number of slots which can be turned into real method
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/game/task/task-control-h_REF.gc
Generated Vendored
+1 -4
View File
@@ -1779,6 +1779,7 @@
(last-ambient string)
(last-ambient-id sound-id)
)
:pack-me
(:methods
(ambient-control-method-9 () none)
(ambient-control-method-10 () none)
@@ -1805,7 +1806,3 @@
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/math/transformq-h_REF.gc
Generated Vendored
+4 -4
View File
@@ -36,9 +36,9 @@
)
(format #t "[~8x] ~A~%" this (-> this type))
(format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
(format #t "~1Trot: ~`vector`P~%" (-> this rot))
(format #t "~1Trot: ~`vector`P~%" (-> this quat))
(format #t "~1Tscale: ~`vector`P~%" (-> this scale))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this rot))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
(label cfg-4)
this
)
@@ -94,9 +94,9 @@ As a result, this type has a lot of weird methods and extra stuff hidden in it."
)
(format #t "[~8x] ~A~%" this (-> this type))
(format #t "~1Ttrans: ~`vector`P~%" (-> this trans))
(format #t "~1Trot: ~`vector`P~%" (-> this rot))
(format #t "~1Trot: ~`vector`P~%" (-> this quat))
(format #t "~1Tscale: ~`vector`P~%" (-> this scale))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this rot))
(format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
(format #t "~1Tpause-adjust-distance: (meters ~m)~%" (-> this pause-adjust-distance))
(format #t "~1Tnav-radius: (meters ~m)~%" (-> this nav-radius))
(format #t "~1Ttransv: ~`vector`P~%" (-> this transv))
test/decompiler/reference/jak3/engine/physics/trajectory-h_REF.gc
Generated Vendored
+249
View File
@@ -0,0 +1,249 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type trajectory
(deftype trajectory (structure)
((initial-position vector :inline)
(initial-velocity vector :inline)
(time float)
(gravity meters)
)
(:methods
(trajectory-method-9 () none)
(trajectory-method-10 () none)
(trajectory-method-11 () none)
(trajectory-method-12 () none)
(trajectory-method-13 () none)
(trajectory-method-14 () none)
(trajectory-method-15 () none)
(trajectory-method-16 () none)
(trajectory-method-17 () none)
)
)
;; definition for method 3 of type trajectory
(defmethod inspect ((this trajectory))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'trajectory)
(format #t "~1Tinitial-position: ~`vector`P~%" (-> this initial-position))
(format #t "~1Tinitial-velocity: ~`vector`P~%" (-> this initial-velocity))
(format #t "~1Ttime: ~f~%" (-> this time))
(format #t "~1Tgravity: (meters ~m)~%" (-> this gravity))
(label cfg-4)
this
)
;; definition of type impact-control
(deftype impact-control (structure)
((process (pointer process-drawable))
(radius meters)
(joint int32)
(collide-with collide-spec)
(start-time uint64)
(trans vector 2 :inline)
(dir vector :inline)
)
(:methods
(new (symbol type process-drawable int float collide-spec) _type_)
(initialize (_type_ process-drawable int float collide-spec) impact-control)
(impact-control-method-10 () none)
(impact-control-method-11 () none)
)
)
;; definition for method 3 of type impact-control
(defmethod inspect ((this impact-control))
(when (not this)
(set! this this)
(goto cfg-7)
)
(format #t "[~8x] ~A~%" this 'impact-control)
(format #t "~1Tprocess: #x~X~%" (-> this process))
(format #t "~1Tradius: (meters ~m)~%" (-> this radius))
(format #t "~1Tjoint: ~D~%" (-> this joint))
(format #t "~1Tcollide-with: ~D~%" (-> this collide-with))
(format #t "~1Tstart-time: ~D~%" (-> this start-time))
(format #t "~1Ttrans[2] @ #x~X~%" (-> this trans))
(dotimes (s5-0 2)
(format #t "~T [~D]~1Ttrans: ~`vector`P~%" s5-0 (-> this trans s5-0))
)
(format #t "~1Tdir: ~`vector`P~%" (-> this dir))
(label cfg-7)
this
)
;; definition for method 0 of type impact-control
(defmethod new impact-control ((allocation symbol) (type-to-make type) (arg0 process-drawable) (arg1 int) (arg2 float) (arg3 collide-spec))
(let ((t9-0 (method-of-type structure new))
(v1-1 type-to-make)
)
(-> type-to-make size)
((method-of-type impact-control initialize)
(the-as impact-control (t9-0 allocation v1-1))
arg0
arg1
arg2
arg3
)
)
)
;; definition of type point-tracker
(deftype point-tracker (structure)
((trans vector 2 :inline)
)
(:methods
(new (symbol type vector vector) _type_)
(initialize (_type_ vector vector) point-tracker)
(point-tracker-method-10 () none)
(point-tracker-method-11 () none)
)
)
;; definition for method 3 of type point-tracker
(defmethod inspect ((this point-tracker))
(when (not this)
(set! this this)
(goto cfg-7)
)
(format #t "[~8x] ~A~%" this 'point-tracker)
(format #t "~1Ttrans[2] @ #x~X~%" (-> this trans))
(dotimes (s5-0 2)
(format #t "~T [~D]~1Ttrans: ~`vector`P~%" s5-0 (-> this trans s5-0))
)
(label cfg-7)
this
)
;; definition for method 0 of type point-tracker
(defmethod new point-tracker ((allocation symbol) (type-to-make type) (arg0 vector) (arg1 vector))
(let ((t9-0 (method-of-type structure new))
(v1-1 type-to-make)
)
(-> type-to-make size)
((method-of-type point-tracker initialize) (the-as point-tracker (t9-0 allocation v1-1)) arg0 arg1)
)
)
;; definition of type combo-tracker
(deftype combo-tracker (point-tracker)
((target handle)
(move-start-time time-frame)
)
(:methods
(combo-tracker-method-12 () none)
(combo-tracker-method-13 () none)
)
)
;; definition for method 3 of type combo-tracker
(defmethod inspect ((this combo-tracker))
(when (not this)
(set! this this)
(goto cfg-7)
)
(format #t "[~8x] ~A~%" this 'combo-tracker)
(format #t "~1Ttrans[2] @ #x~X~%" (-> this trans))
(dotimes (s5-0 2)
(format #t "~T [~D]~1Ttrans: ~`vector`P~%" s5-0 (-> this trans s5-0))
)
(format #t "~1Ttarget: ~D~%" (-> this target))
(format #t "~1Tmove-start-time: ~D~%" (-> this move-start-time))
(label cfg-7)
this
)
;; definition of type traj2d-params
(deftype traj2d-params (structure)
((x float)
(y float)
(gravity float)
(initial-tilt float)
(initial-speed float)
(time float)
)
)
;; definition for method 3 of type traj2d-params
(defmethod inspect ((this traj2d-params))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'traj2d-params)
(format #t "~1Tx: ~f~%" (-> this x))
(format #t "~1Ty: ~f~%" (-> this y))
(format #t "~1Tgravity: ~f~%" (-> this gravity))
(format #t "~1Tinitial-tilt: ~f~%" (-> this initial-tilt))
(format #t "~1Tinitial-speed: ~f~%" (-> this initial-speed))
(format #t "~1Ttime: ~f~%" (-> this time))
(label cfg-4)
this
)
;; definition of type traj3d-params
(deftype traj3d-params (structure)
((gravity float)
(initial-tilt float)
(initial-speed float)
(time float)
(src vector :inline)
(dest vector :inline)
(diff vector :inline)
(initial-velocity vector :inline)
)
)
;; definition for method 3 of type traj3d-params
(defmethod inspect ((this traj3d-params))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'traj3d-params)
(format #t "~1Tgravity: ~f~%" (-> this gravity))
(format #t "~1Tinitial-tilt: ~f~%" (-> this initial-tilt))
(format #t "~1Tinitial-speed: ~f~%" (-> this initial-speed))
(format #t "~1Ttime: ~f~%" (-> this time))
(format #t "~1Tsrc: #<vector @ #x~X>~%" (-> this src))
(format #t "~1Tdest: #<vector @ #x~X>~%" (-> this dest))
(format #t "~1Tdiff: #<vector @ #x~X>~%" (-> this diff))
(format #t "~1Tinitial-velocity: #<vector @ #x~X>~%" (-> this initial-velocity))
(label cfg-4)
this
)
;; definition of type cubic-curve
(deftype cubic-curve (structure)
((mat matrix :inline)
)
(:methods
(cubic-curve-method-9 () none)
(cubic-curve-method-10 () none)
(cubic-curve-method-11 () none)
(cubic-curve-method-12 () none)
(cubic-curve-method-13 () none)
)
)
;; definition for method 3 of type cubic-curve
(defmethod inspect ((this cubic-curve))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'cubic-curve)
(format #t "~1Tmat: #<matrix @ #x~X>~%" (-> this mat))
(label cfg-4)
this
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/process-drawable/focus_REF.gc
Generated Vendored
+77
View File
@@ -0,0 +1,77 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type focus
(deftype focus (structure)
"A structure that keeps a handle to a [[process-focusable]]."
((handle handle)
(collide-with collide-spec)
)
(:methods
(clear-focused (_type_) none)
(collide-check? (_type_ process-focusable) object)
(reset-to-collide-spec (_type_ collide-spec) none)
(try-update-focus (_type_ process-focusable) symbol)
)
)
;; definition for method 3 of type focus
(defmethod inspect ((this focus))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'focus)
(format #t "~1Thandle: ~D~%" (-> this handle))
(format #t "~1Tcollide-with: ~D~%" (-> this collide-with))
(label cfg-4)
this
)
;; definition for method 11 of type focus
;; WARN: Return type mismatch int vs none.
(defmethod reset-to-collide-spec ((this focus) (cspec collide-spec))
"Reset this focus with the given [[collide-spec]]."
(set! (-> this collide-with) cspec)
(set! (-> this handle) (the-as handle #f))
0
(none)
)
;; definition for method 10 of type focus
(defmethod collide-check? ((this focus) (proc process-focusable))
"If the focused process is not dead,
check that the [[collide-spec]] of the focus and the process match."
(when (and proc (not (logtest? (-> proc focus-status) (focus-status disable dead))))
(let* ((root (-> proc root))
(cshape (if (type? root collide-shape)
root
)
)
)
(and cshape (logtest? (-> this collide-with) (-> cshape root-prim prim-core collide-as)))
)
)
)
;; definition for method 12 of type focus
(defmethod try-update-focus ((this focus) (proc process-focusable))
"Try to set the `handle` of this focus to the given process."
(when (!= (handle->process (-> this handle)) proc)
(set! (-> this handle) (process->handle proc))
#t
)
)
;; definition for method 9 of type focus
;; WARN: Return type mismatch int vs none.
(defmethod clear-focused ((this focus))
"Reset the focus' handle."
(set! (-> this handle) (the-as handle #f))
0
(none)
)
test/decompiler/reference/jak3/engine/process-drawable/process-drawable-h_REF.gc
Generated Vendored
+193
View File
@@ -0,0 +1,193 @@
;;-*-Lisp-*-
(in-package goal)
;; definition for function cspace-by-name-no-fail
;; WARN: Return type mismatch object vs cspace.
(defun cspace-by-name-no-fail ((proc process-drawable) (name string))
"Like [[cspace-by-name]], but prints an error if the [[cspace]] was not found and returns the `node-list`."
(let ((v0-0 (the-as object (cspace-by-name proc name))))
(the-as cspace (cond
((the-as cspace v0-0)
(empty)
v0-0
)
(else
(format 0 "no cspace (~A)~%" name)
(-> proc node-list data)
)
)
)
)
)
;; definition for function cspace-index-by-name-no-fail
(defun cspace-index-by-name-no-fail ((proc process-drawable) (name string))
"Like [[cspace-index-by-name]], but prints an error if the [[cspace]] was not found and returns 0."
(let ((idx (cspace-index-by-name proc name)))
(cond
((< idx 0)
(format 0 "no cspace[ndx] (~A)~%" name)
0
)
(else
(empty)
idx
)
)
)
)
;; definition for function num-func-none
(defbehavior num-func-none process ((chan joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(-> chan frame-num)
)
;; definition for function num-func-+!
(defbehavior num-func-+! process ((chan joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(set! (-> chan frame-num)
(+ (-> chan frame-num) (* arg1 (* (-> chan frame-group speed) (-> self clock time-adjust-ratio))))
)
)
;; definition for function num-func--!
(defbehavior num-func--! process ((chan joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(set! (-> chan frame-num)
(- (-> chan frame-num) (* arg1 (* (-> chan frame-group speed) (-> self clock time-adjust-ratio))))
)
)
;; definition for function num-func-loop!
(defbehavior num-func-loop! process ((chan joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(let* ((f0-1 (the float (+ (-> chan frame-group frames num-frames) -1)))
(f1-2 (+ (-> chan frame-num) f0-1 (* arg1 (* (-> chan frame-group speed) (-> self clock time-adjust-ratio)))))
)
(set! (-> chan frame-num) (- f1-2 (* (the float (the int (/ f1-2 f0-1))) f0-1)))
)
)
;; definition for function num-func-loop-speedless!
(defbehavior num-func-loop-speedless! process ((arg0 joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(let* ((f0-1 (the float (+ (-> arg0 frame-group frames num-frames) -1)))
(f1-2 (+ (-> arg0 frame-num) f0-1 arg1))
)
(set! (-> arg0 frame-num) (- f1-2 (* (the float (the int (/ f1-2 f0-1))) f0-1)))
)
)
;; definition for function num-func-loop-set!
(defbehavior num-func-loop-set! process ((chan joint-control-channel) (frame float) (arg2 float) (arg3 float))
(set! (-> chan frame-num) frame)
frame
)
;; definition for function num-func-seek!
(defbehavior num-func-seek! process ((chan joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(set! (-> chan frame-num)
(seek (-> chan frame-num) arg1 (* arg2 (* (-> chan frame-group speed) (-> self clock time-adjust-ratio))))
)
)
;; definition for function num-func-blend-in!
(defbehavior num-func-blend-in! process ((arg0 joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(let ((f30-0 (seek (-> arg0 frame-interp 0) 1.0 (* arg1 (-> self clock time-adjust-ratio)))))
(set! (-> arg0 frame-interp 0) f30-0)
(set! (-> arg0 frame-interp 1) f30-0)
(if (= f30-0 1.0)
(joint-control-reset! (-> arg0 parent) arg0)
)
f30-0
)
)
;; definition for function joint-channel-float-delete!
;; WARN: Return type mismatch int vs none.
(defun joint-channel-float-delete! ((chan joint-control-channel))
(let ((v1-0 (-> chan parent)))
(+! (-> v1-0 float-channels) -1)
(when (nonzero? (-> v1-0 float-channels))
(let ((a1-5 (/ (&- (the-as pointer chan) (the-as uint (the-as pointer (-> v1-0 channel)))) 64)))
(if (< a1-5 (the-as int (+ (-> v1-0 active-channels) (-> v1-0 float-channels))))
(qmem-copy<-!
(the-as pointer (+ (+ (* a1-5 64) 60) (the-as int v1-0)))
(the-as pointer (+ (+ (* (+ a1-5 1) 64) 60) (the-as int v1-0)))
(the-as int (* (-> v1-0 float-channels) 64))
)
)
)
)
)
0
(none)
)
;; definition for function num-func-interp-play!
(defbehavior num-func-interp-play! process ((arg0 joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(let ((f30-0 (the float (+ (-> arg0 frame-group frames num-frames) -1)))
(f28-0 (* arg3 (-> arg0 frame-group speed)))
)
(seek! (-> arg0 frame-num) f30-0 (* arg1 (* (-> arg0 frame-group speed) (-> self clock time-adjust-ratio))))
(cond
((< (-> arg0 frame-num) f28-0)
(set! (-> arg0 frame-interp 0) (/ (* (-> arg0 frame-num) arg2) f28-0))
)
((< (- f30-0 f28-0) (-> arg0 frame-num))
(set! (-> arg0 frame-interp 0) (/ (* (- f30-0 (-> arg0 frame-num)) arg2) f28-0))
(when (and (= (-> arg0 frame-num) f30-0) (logtest? (-> arg0 command) (joint-control-command eight)))
(joint-channel-float-delete! arg0)
(return 0.0)
)
)
(else
(set! (-> arg0 frame-interp 0) arg2)
)
)
)
(set! (-> arg0 frame-interp 1) (-> arg0 frame-interp 0))
(-> arg0 frame-num)
)
;; definition for function num-func-interp1-play!
(defbehavior num-func-interp1-play! process ((arg0 joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(let ((f30-0 (the float (+ (-> arg0 frame-group frames num-frames) -1)))
(f28-0 (* arg3 (-> arg0 frame-group speed)))
)
(seek! (-> arg0 frame-num) f30-0 (* arg1 (* (-> arg0 frame-group speed) (-> self clock time-adjust-ratio))))
(cond
((< (-> arg0 frame-num) f28-0)
(set! (-> arg0 frame-interp 1) (/ (* (-> arg0 frame-num) arg2) f28-0))
)
((< (- f30-0 f28-0) (-> arg0 frame-num))
(set! (-> arg0 frame-interp 1) (/ (* (- f30-0 (-> arg0 frame-num)) arg2) f28-0))
(when (and (= (-> arg0 frame-num) f30-0) (logtest? (-> arg0 command) (joint-control-command eight)))
(joint-channel-float-delete! arg0)
(return 0.0)
)
)
(else
(set! (-> arg0 frame-interp 1) arg2)
)
)
)
(-> arg0 frame-num)
)
;; definition for function num-func-chan
(defbehavior num-func-chan process ((arg0 joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(set! (-> arg0 frame-num)
(-> (the-as joint-control-channel (+ (the-as uint arg0) (* (- (the int arg1) (-> arg0 group-sub-index)) 64)))
frame-num
)
)
)
;; definition for function num-func-identity
(defbehavior num-func-identity process ((chan joint-control-channel) (arg1 float) (arg2 float) (arg3 float))
(-> chan frame-num)
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/process-drawable/process-focusable_REF.gc
Generated Vendored
+115
View File
@@ -0,0 +1,115 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type process-focusable
(deftype process-focusable (process-drawable)
((root collide-shape :override)
(focus-status focus-status)
)
(:methods
(process-focusable-method-20 (_type_) int)
(get-trans (_type_ int) vector)
(get-quat (_type_) quaternion)
(get-transv (_type_) vector)
(time-to-apex-or-ground (_type_ int) int)
(get-water-height (_type_) meters)
(get-notice-time (_type_) time-frame)
(get-inv-mass (_type_) float)
)
)
;; definition for method 3 of type process-focusable
(defmethod inspect ((this process-focusable))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 this)
)
(format #t "~2Tfocus-status: ~D~%" (-> this focus-status))
(label cfg-4)
this
)
;; definition for method 20 of type process-focusable
(defmethod process-focusable-method-20 ((this process-focusable))
(let ((v0-0 0))
(let ((mask (-> this mask)))
(if (logtest? (process-mask crate) mask)
(set! v0-0 (logior v0-0 2))
)
(if (logtest? (process-mask guard) mask)
(set! v0-0 (logior v0-0 4))
)
(if (logtest? (process-mask enemy) mask)
(set! v0-0 (logior v0-0 16))
)
)
v0-0
)
)
;; definition for method 21 of type process-focusable
;; WARN: Return type mismatch structure vs vector.
(defmethod get-trans ((this process-focusable) (mode int))
"Get the `trans` for this process."
(let ((cshape (-> this root)))
(the-as vector (cond
((zero? mode)
(-> cshape trans)
)
((and (= mode 1) (type? cshape collide-shape-moving))
(-> (the-as collide-shape-moving cshape) gspot-pos)
)
((and (or (= mode 2) (= mode 3) (= mode 10)) (type? cshape collide-shape))
(-> (the-as collide-shape-moving cshape) root-prim prim-core)
)
(else
(-> cshape trans)
)
)
)
)
)
;; definition for method 23 of type process-focusable
(defmethod get-transv ((this process-focusable))
"Get the `transv` for this process."
(-> this root transv)
)
;; definition for method 22 of type process-focusable
(defmethod get-quat ((this process-focusable))
"Get the quaternion for this process."
(-> this root quat)
)
;; definition for method 24 of type process-focusable
(defmethod time-to-apex-or-ground ((this process-focusable) (arg0 int))
0
)
;; definition for method 25 of type process-focusable
;; WARN: Return type mismatch int vs meters.
(defmethod get-water-height ((this process-focusable))
(the-as meters 0)
)
;; definition for method 27 of type process-focusable
(defmethod get-inv-mass ((this process-focusable))
0.0
)
;; definition for method 26 of type process-focusable
;; WARN: Return type mismatch int vs time-frame.
(defmethod get-notice-time ((this process-focusable))
(the-as time-frame 0)
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/process-drawable/process-taskable-h_REF.gc
Generated Vendored
+66
View File
@@ -0,0 +1,66 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type process-taskable
(deftype process-taskable (process-focusable)
"The parent class for NPCs that can be talked to."
((flags process-taskable-flags)
(task game-task-control)
(ambient ambient-control :inline :offset 216)
(neck-joint-index int32)
(talk-message text-id)
(talk-distance meters)
(talk-height meters)
(last-talk time-frame)
(want-to-say time-frame)
(birth-time time-frame)
(slave handle)
)
(:state-methods
hide
idle
(active game-task-event)
die
(play-game game-task-event)
)
(:methods
(process-taskable-method-33 () none)
(process-taskable-method-34 () none)
(process-taskable-method-35 () none)
(process-taskable-method-36 () none)
(process-taskable-method-37 () none)
(process-taskable-method-38 () none)
(process-taskable-method-39 () none)
)
)
;; definition for method 3 of type process-taskable
(defmethod inspect ((this process-taskable))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-focusable inspect)))
(t9-0 this)
)
(format #t "~2Tflags: ~D~%" (-> this flags))
(format #t "~2Ttask: ~A~%" (-> this task))
(format #t "~2Tambient: #<ambient-control @ #x~X>~%" (-> this ambient))
(format #t "~2Tneck-joint-index: ~D~%" (-> this neck-joint-index))
(format #t "~2Ttalk-message: ~D~%" (-> this talk-message))
(format #t "~2Ttalk-distance: (meters ~m)~%" (-> this talk-distance))
(format #t "~2Ttalk-height: (meters ~m)~%" (-> this talk-height))
(format #t "~2Tlast-talk: ~D~%" (-> this last-talk))
(format #t "~2Twant-to-say: ~D~%" (-> this want-to-say))
(format #t "~2Tbirth-time: ~D~%" (-> this birth-time))
(format #t "~2Tslave: ~D~%" (-> this slave))
(label cfg-4)
this
)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/target/target-h_REF.gc
Generated Vendored
+436
View File
@@ -0,0 +1,436 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type target
(deftype target (process-focusable)
((control control-info :overlay-at root)
(skel2 joint-control)
(shadow-backup shadow-geo)
(target-flags target-flags :overlay-at state-flags)
(game game-info)
(neck joint-mod)
(head joint-mod)
(upper-body joint-mod)
(horns joint-mod)
(hair joint-mod 2)
(arm-ik joint-mod-ik 2)
(leg-ik joint-mod-ik 2)
(foot joint-mod 2)
(cloth basic)
(init-time time-frame)
(teleport-time time-frame)
(state-hook-time time-frame)
(state-hook (function none :behavior target))
(cam-user-mode symbol)
(sidekick (pointer sidekick))
(manipy (pointer manipy))
(mirror (pointer process-drawable))
(attack-info attack-info :inline)
(attack-info-rec attack-info :inline)
(attack-info-old attack-info 8 :inline)
(anim-seed uint64)
(alt-cam-pos vector :inline)
(current-level level)
(saved-pos transformq :inline)
(saved-owner handle)
(alt-neck-pos vector :inline)
(focus-search (array collide-shape))
(handle-search (array handle))
(excitement float)
(shock-effect-time time-frame)
(beard? symbol)
(spool-anim spool-anim)
(ambient-time time-frame)
(fp-hud handle)
(no-load-wait uint64)
(no-look-around-wait uint64)
(burn-proc handle)
(pre-joint-hook (function none :behavior target))
(notify handle)
(death-resetter resetter-spec :inline)
(mode-cache basic)
(mode-param1 uint64)
(mode-param2 uint64)
(mode-param3 uint64)
(major-mode-exit-hook basic)
(major-mode-event-hook basic)
(sub-mode-exit-hook basic)
(ext-geo-control basic)
(pending-ext-geo int32)
(ext-geo int32)
(ext-anim-control basic)
(pending-ext-anim int32)
(ext-anim int32)
(tobot-state state)
(tobot? symbol)
(tobot-recorder basic)
(target-effect uint64)
(color-effect basic)
(color-effect-start-time time-frame)
(color-effect-duration time-frame)
(racer racer-info)
(tube tube-info)
(flut flut-info)
(board board-info)
(pilot pilot-info)
(gun gun-info)
(mech mech-info)
(turret turret-info)
(indax indax-info)
(ladder ladder-info)
(darkjak-interp float)
(darkjak-interp-old float)
(darkjak-giant-interp float)
(darkjak darkjak-info)
(lightjak-interp float)
(lightjak-interp-old float)
(lightjak lightjak-info)
(scarf-interp-targ float)
(scarf-interp float)
(scarf-interp-old float)
(goggles-interp-targ float)
(goggles-interp float)
(goggles-interp-old float)
(invisible-interp float)
(invisible-start-time time-frame)
(invisible-duration time-frame)
(invisible-shadow-dir-backup vector :inline)
)
(:methods
(target-method-28 () none)
(target-method-29 () none)
)
(:states
target-attack
target-attack-air
target-attack-uppercut
target-attack-uppercut-jump
target-blast-recover
target-board-clone-anim
target-board-duck-stance
target-board-falling
target-board-flip
target-board-get-off
target-board-get-on
target-board-grab
target-board-grenade
target-board-halfpipe
target-board-hit
target-board-hit-ground
target-board-hold
target-board-jump
target-board-jump-kick
target-board-ride-edge
target-board-stance
target-board-start
target-board-trickx
target-board-tricky
target-board-turn-around
target-board-turn-to
target-board-wall-kick
target-clone-anim
target-continue
target-credits
target-darkjak-bomb0
target-darkjak-bomb1
target-darkjak-get-off
target-darkjak-get-on
target-darkjak-running-attack
target-darkjak-smack
target-darkjak-smack-charge
target-death
target-double-jump
target-duck-high-jump
target-duck-high-jump-jump
target-duck-stance
target-duck-walk
target-eco-powerup
target-edge-grab
target-edge-grab-jump
target-edge-grab-off
target-falling
target-float
target-flop
target-flop-hit-ground
target-flut-air-attack
target-flut-air-attack-hit-ground
target-flut-clone-anim
target-flut-death
target-flut-double-jump
target-flut-eject
target-flut-falling
target-flut-get-off
target-flut-get-off-jump
target-flut-get-on
target-flut-grab
target-flut-hit
target-flut-hit-ground
target-flut-jump
target-flut-kanga-catch
target-flut-running-attack
target-flut-stance
target-flut-start
target-flut-walk
target-grab
target-grab-ride
target-gun-stance
target-gun-walk
target-hide
target-high-jump
target-hit
target-hit-ground
target-hit-ground-hard
target-indax-attack
target-indax-attack-air
target-indax-death
target-indax-double-jump
target-indax-falling
target-indax-get-off
target-indax-grab
target-indax-hang
target-indax-hit
target-indax-hit-ground
target-indax-jump
target-indax-running-attack
target-indax-stance
target-indax-start
target-indax-trip
target-indax-walk
target-invisible-get-on
target-jump
target-jump-forward
target-ladder
target-launch
target-launch-dir
target-lightjak-freeze
target-lightjak-get-off
target-lightjak-get-on
target-lightjak-regen
target-lightjak-shield
target-lightjak-swoop
target-lightjak-swoop-again
target-lightjak-swoop-falling
target-load-wait
target-look-around
target-mech-carry-drag
target-mech-carry-drop
target-mech-carry-falling
target-mech-carry-hit-ground
target-mech-carry-jump
target-mech-carry-pickup
target-mech-carry-stance
target-mech-carry-throw
target-mech-carry-walk
target-mech-clone-anim
target-mech-death
target-mech-falling
target-mech-get-off
target-mech-get-on
target-mech-get-up
target-mech-grab
target-mech-hit
target-mech-hit-ground
target-mech-jump
target-mech-punch
target-mech-shield
target-mech-stance
target-mech-start
target-mech-walk
target-pilot-clone-anim
target-pilot-daxter-perch
target-pilot-death
target-pilot-edge-grab
target-pilot-get-off
target-pilot-get-on
target-pilot-grab
target-pilot-hit
target-pilot-impact
target-pilot-stance
target-pilot-start
target-play-anim
target-pole-cycle
target-pole-flip-forward
target-pole-flip-forward-jump
target-pole-flip-up
target-pole-flip-up-jump
target-powerjak-get-on
target-roll
target-roll-flip
target-running-attack
target-slide-down
target-slide-down-to-ground
target-stance
target-stance-ambient
target-stance-look-around
target-swim
target-swim-jump
target-title
target-tube
target-turn-around
target-wade-stance
target-wade-walk
target-walk
target-warp-in
target-warp-out
)
)
;; definition for method 3 of type target
(defmethod inspect ((this target))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-focusable inspect)))
(t9-0 this)
)
(format #t "~2Tcontrol: ~A~%" (-> this control))
(format #t "~2Tskel2: ~A~%" (-> this skel2))
(format #t "~2Tshadow-backup: ~A~%" (-> this shadow-backup))
(format #t "~2Ttarget-flags: ~D~%" (-> this target-flags))
(format #t "~2Tgame: ~A~%" (-> this game))
(format #t "~2Tneck: ~A~%" (-> this neck))
(format #t "~2Thead: ~A~%" (-> this head))
(format #t "~2Tupper-body: ~A~%" (-> this upper-body))
(format #t "~2Thorns: ~A~%" (-> this horns))
(format #t "~2Thair[2] @ #x~X~%" (-> this hair))
(format #t "~2Tarm-ik[2] @ #x~X~%" (-> this arm-ik))
(format #t "~2Tleg-ik[2] @ #x~X~%" (-> this leg-ik))
(format #t "~2Tfoot[2] @ #x~X~%" (-> this foot))
(format #t "~2Tcloth: ~A~%" (-> this cloth))
(format #t "~2Tinit-time: ~D~%" (-> this init-time))
(format #t "~2Tteleport-time: ~D~%" (-> this teleport-time))
(format #t "~2Tstate-hook-time: ~D~%" (-> this state-hook-time))
(format #t "~2Tstate-hook: ~A~%" (-> this state-hook))
(format #t "~2Tcam-user-mode: ~A~%" (-> this cam-user-mode))
(format #t "~2Tsidekick: #x~X~%" (-> this sidekick))
(format #t "~2Tmanipy: #x~X~%" (-> this manipy))
(format #t "~2Tmirror: #x~X~%" (-> this mirror))
(format #t "~2Tattack-info: #<attack-info @ #x~X>~%" (-> this attack-info))
(format #t "~2Tattack-info-rec: #<attack-info @ #x~X>~%" (-> this attack-info-rec))
(format #t "~2Tattack-info-old[8] @ #x~X~%" (-> this attack-info-old))
(format #t "~2Tanim-seed: ~D~%" (-> this anim-seed))
(format #t "~2Talt-cam-pos: ~`vector`P~%" (-> this alt-cam-pos))
(format #t "~2Tcurrent-level: ~A~%" (-> this current-level))
(format #t "~2Tsaved-pos: #<transformq @ #x~X>~%" (-> this saved-pos))
(format #t "~2Tsaved-owner: ~D~%" (-> this saved-owner))
(format #t "~2Talt-neck-pos: ~`vector`P~%" (-> this alt-neck-pos))
(format #t "~2Tfocus-search: ~A~%" (-> this focus-search))
(format #t "~2Thandle-search: ~A~%" (-> this handle-search))
(format #t "~2Texcitement: ~f~%" (-> this excitement))
(format #t "~2Tshock-effect-time: ~D~%" (-> this shock-effect-time))
(format #t "~2Tbeard?: ~A~%" (-> this beard?))
(format #t "~2Tspool-anim: ~A~%" (-> this spool-anim))
(format #t "~2Tambient-time: ~D~%" (-> this ambient-time))
(format #t "~2Tfp-hud: ~D~%" (-> this fp-hud))
(format #t "~2Tno-load-wait: ~D~%" (-> this no-load-wait))
(format #t "~2Tno-look-around-wait: ~D~%" (-> this no-look-around-wait))
(format #t "~2Tburn-proc: ~D~%" (-> this burn-proc))
(format #t "~2Tpre-joint-hook: ~A~%" (-> this pre-joint-hook))
(format #t "~2Tnotify: ~D~%" (-> this notify))
(format #t "~2Tdeath-resetter: #<resetter-spec @ #x~X>~%" (-> this death-resetter))
(format #t "~2Tmode-cache: ~A~%" (-> this mode-cache))
(format #t "~2Tmode-param1: ~D~%" (-> this mode-param1))
(format #t "~2Tmode-param2: ~A~%" (-> this mode-param2))
(format #t "~2Tmode-param3: ~A~%" (-> this mode-param3))
(format #t "~2Tmajor-mode-exit-hook: ~A~%" (-> this major-mode-exit-hook))
(format #t "~2Tmajor-mode-event-hook: ~A~%" (-> this major-mode-event-hook))
(format #t "~2Tsub-mode-exit-hook: ~A~%" (-> this sub-mode-exit-hook))
(format #t "~2Text-geo-control: ~A~%" (-> this ext-geo-control))
(format #t "~2Tpending-ext-geo: ~D~%" (-> this pending-ext-geo))
(format #t "~2Text-geo: ~D~%" (-> this ext-geo))
(format #t "~2Text-anim-control: ~A~%" (-> this ext-anim-control))
(format #t "~2Tpending-ext-anim: ~D~%" (-> this pending-ext-anim))
(format #t "~2Text-anim: ~D~%" (-> this ext-anim))
(format #t "~2Ttobot-state: ~A~%" (-> this tobot-state))
(format #t "~2Ttobot?: ~A~%" (-> this tobot?))
(format #t "~2Ttobot-recorder: ~A~%" (-> this tobot-recorder))
(format #t "~2Ttarget-effect: ~D~%" (-> this target-effect))
(format #t "~2Tcolor-effect: ~A~%" (-> this color-effect))
(format #t "~2Tcolor-effect-start-time: ~D~%" (-> this color-effect-start-time))
(format #t "~2Tcolor-effect-duration: ~D~%" (-> this color-effect-duration))
(format #t "~2Tracer: ~A~%" (-> this racer))
(format #t "~2Ttube: ~A~%" (-> this tube))
(format #t "~2Tflut: ~A~%" (-> this flut))
(format #t "~2Tboard: ~A~%" (-> this board))
(format #t "~2Tpilot: ~A~%" (-> this pilot))
(format #t "~2Tgun: ~A~%" (-> this gun))
(format #t "~2Tmech: ~A~%" (-> this mech))
(format #t "~2Tturret: ~A~%" (-> this turret))
(format #t "~2Tindax: ~A~%" (-> this indax))
(format #t "~2Tladder: ~A~%" (-> this ladder))
(format #t "~2Tdarkjak-interp: ~f~%" (-> this darkjak-interp))
(format #t "~2Tdarkjak-interp-old: ~f~%" (-> this darkjak-interp-old))
(format #t "~2Tdarkjak-giant-interp: ~f~%" (-> this darkjak-giant-interp))
(format #t "~2Tdarkjak: ~A~%" (-> this darkjak))
(format #t "~2Tlightjak-interp: ~f~%" (-> this lightjak-interp))
(format #t "~2Tlightjak-interp-old: ~f~%" (-> this lightjak-interp-old))
(format #t "~2Tlightjak: ~A~%" (-> this lightjak))
(format #t "~2Tscarf-interp-targ: ~f~%" (-> this scarf-interp-targ))
(format #t "~2Tscarf-interp: ~f~%" (-> this scarf-interp))
(format #t "~2Tscarf-interp-old: ~f~%" (-> this scarf-interp-old))
(format #t "~2Tgoggles-interp-targ: ~f~%" (-> this goggles-interp-targ))
(format #t "~2Tgoggles-interp: ~f~%" (-> this goggles-interp))
(format #t "~2Tgoggles-interp-old: ~f~%" (-> this goggles-interp-old))
(format #t "~2Tinvisible-interp: ~f~%" (-> this invisible-interp))
(format #t "~2Tinvisible-start-time: ~D~%" (-> this invisible-start-time))
(format #t "~2Tinvisible-duration: ~D~%" (-> this invisible-duration))
(format #t "~2Tinvisible-shadow-dir-backup: #<vector @ #x~X>~%" (-> this invisible-shadow-dir-backup))
(label cfg-4)
this
)
;; definition (perm) for symbol *target*, type target
(define-perm *target* target #f)
;; definition of type sidekick
(deftype sidekick (process-drawable)
((control control-info :overlay-at root)
(anim-seed uint64 :offset 208)
(shadow-in-movie? symbol)
(special-anim-time time-frame)
(special-anim-interp float)
(special-anim-frame float)
(offset transformq :inline)
(mirror (pointer process-drawable))
(ear joint-mod 2)
(flap joint-mod 2)
)
(:states
sidekick-clone
)
)
;; definition for method 3 of type sidekick
(defmethod inspect ((this sidekick))
(when (not this)
(set! this this)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 this)
)
(format #t "~2Tcontrol: ~A~%" (-> this control))
(format #t "~2Tstate-time: ~D~%" (-> this state-time))
(format #t "~2Tanim-seed: ~D~%" (-> this anim-seed))
(format #t "~2Tshadow-in-movie?: ~A~%" (-> this shadow-in-movie?))
(format #t "~2Tspecial-anim-time: ~D~%" (-> this special-anim-time))
(format #t "~2Tspecial-anim-interp: ~f~%" (-> this special-anim-interp))
(format #t "~2Tspecial-anim-frame: ~f~%" (-> this special-anim-frame))
(format #t "~2Toffset: #<transformq @ #x~X>~%" (-> this offset))
(format #t "~2Tmirror: #x~X~%" (-> this mirror))
(format #t "~2Tear[2] @ #x~X~%" (-> this ear))
(format #t "~2Tflap[2] @ #x~X~%" (-> this flap))
(label cfg-4)
this
)
;; definition (perm) for symbol *sidekick*, type sidekick
(define-perm *sidekick* sidekick #f)
;; failed to figure out what this is:
0
test/decompiler/reference/jak3/engine/util/sync-info-h_REF.gc
Generated Vendored
+321
View File
@@ -0,0 +1,321 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type sync-info-params
(deftype sync-info-params (structure)
"Parameters used to set up a [[sync-info]]."
((sync-type symbol)
(sync-flags sync-flags)
(entity basic)
(period uint32)
(percent float)
(ease-in float)
(ease-out float)
(pause-in float)
(pause-out float)
)
)
;; definition for method 3 of type sync-info-params
(defmethod inspect ((this sync-info-params))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'sync-info-params)
(format #t "~1Tsync-type: ~A~%" (-> this sync-type))
(format #t "~1Tsync-flags: ~D~%" (-> this sync-flags))
(format #t "~1Tentity: ~A~%" (-> this entity))
(format #t "~1Tperiod: ~D~%" (-> this period))
(format #t "~1Tpercent: ~f~%" (-> this percent))
(format #t "~1Tease-in: ~f~%" (-> this ease-in))
(format #t "~1Tease-out: ~f~%" (-> this ease-out))
(format #t "~1Tpause-in: ~f~%" (-> this pause-in))
(format #t "~1Tpause-out: ~f~%" (-> this pause-out))
(label cfg-4)
this
)
;; definition of type sync-info
(deftype sync-info (structure)
((sync-flags sync-flags)
(offset float)
(period uint32)
)
(:methods
(sync-info-method-9 () none)
(sync-info-method-10 () none)
(sync-info-method-11 () none)
(sync-info-method-12 () none)
(sync-info-method-13 () none)
(sync-info-method-14 () none)
(sync-info-method-15 () none)
)
)
;; definition for method 3 of type sync-info
(defmethod inspect ((this sync-info))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'sync-info)
(format #t "~1Tsync-flags: ~D~%" (-> this sync-flags))
(format #t "~1Toffset: ~f~%" (-> this offset))
(format #t "~1Tperiod: ~D~%" (-> this period))
(label cfg-4)
this
)
;; definition of type sync-linear
(deftype sync-linear (sync-info)
()
:pack-me
)
;; definition for method 3 of type sync-linear
(defmethod inspect ((this sync-linear))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'sync-linear)
(format #t "~1Tsync-flags: ~D~%" (-> this sync-flags))
(format #t "~1Toffset: ~f~%" (-> this offset))
(format #t "~1Tperiod: ~D~%" (-> this period))
(label cfg-4)
this
)
;; definition of type sync-eased
(deftype sync-eased (sync-info)
((tlo float)
(thi float)
(ylo float)
(m2 float)
(yend float)
(pause-in float)
(pause-out float)
)
:pack-me
)
;; definition for method 3 of type sync-eased
(defmethod inspect ((this sync-eased))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'sync-eased)
(format #t "~1Tsync-flags: ~D~%" (-> this sync-flags))
(format #t "~1Toffset: ~f~%" (-> this offset))
(format #t "~1Tperiod: ~D~%" (-> this period))
(format #t "~1Ttlo: ~f~%" (-> this tlo))
(format #t "~1Tthi: ~f~%" (-> this thi))
(format #t "~1Tylo: ~f~%" (-> this ylo))
(format #t "~1Tm2: ~f~%" (-> this m2))
(format #t "~1Tyend: ~f~%" (-> this yend))
(format #t "~1Tpause-in: ~f~%" (-> this pause-in))
(format #t "~1Tpause-out: ~f~%" (-> this pause-out))
(label cfg-4)
this
)
;; definition of type sync-paused
(deftype sync-paused (sync-info)
((pause-in float)
(pause-out float)
)
)
;; definition for method 3 of type sync-paused
(defmethod inspect ((this sync-paused))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'sync-paused)
(format #t "~1Tsync-flags: ~D~%" (-> this sync-flags))
(format #t "~1Toffset: ~f~%" (-> this offset))
(format #t "~1Tperiod: ~D~%" (-> this period))
(format #t "~1Tpause-in: ~f~%" (-> this pause-in))
(format #t "~1Tpause-out: ~f~%" (-> this pause-out))
(label cfg-4)
this
)
;; definition of type delayed-rand-float
(deftype delayed-rand-float (structure)
((min-time int32)
(max-time int32)
(max-val float)
(timer int32)
(start-time time-frame)
(value float)
)
:pack-me
(:methods
(delayed-rand-float-method-9 () none)
(delayed-rand-float-method-10 () none)
(delayed-rand-float-method-11 () none)
(delayed-rand-float-method-12 () none)
)
)
;; definition for method 3 of type delayed-rand-float
(defmethod inspect ((this delayed-rand-float))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'delayed-rand-float)
(format #t "~1Tmin-time: ~D~%" (-> this min-time))
(format #t "~1Tmax-time: ~D~%" (-> this max-time))
(format #t "~1Tmax-val: ~f~%" (-> this max-val))
(format #t "~1Ttimer: ~D~%" (-> this timer))
(format #t "~1Tstart-time: ~D~%" (-> this start-time))
(format #t "~1Tvalue: ~f~%" (-> this value))
(label cfg-4)
this
)
;; definition of type oscillating-float
(deftype oscillating-float (structure)
((value float)
(target float)
(vel float)
(max-vel float)
(damping float)
(accel float)
)
:allow-misaligned
(:methods
(oscillating-float-method-9 () none)
(oscillating-float-method-10 () none)
)
)
;; definition for method 3 of type oscillating-float
(defmethod inspect ((this oscillating-float))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'oscillating-float)
(format #t "~1Tvalue: ~f~%" (-> this value))
(format #t "~1Ttarget: ~f~%" (-> this target))
(format #t "~1Tvel: ~f~%" (-> this vel))
(format #t "~1Tmax-vel: ~f~%" (-> this max-vel))
(format #t "~1Tdamping: ~f~%" (-> this damping))
(format #t "~1Taccel: ~f~%" (-> this accel))
(label cfg-4)
this
)
;; definition of type bouncing-float
(deftype bouncing-float (structure)
((osc oscillating-float :inline)
(max-value float)
(min-value float)
(elasticity float)
(state int32)
)
:allow-misaligned
(:methods
(bouncing-float-method-9 () none)
(bouncing-float-method-10 () none)
(bouncing-float-method-11 () none)
(bouncing-float-method-12 () none)
)
)
;; definition for method 3 of type bouncing-float
(defmethod inspect ((this bouncing-float))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'bouncing-float)
(format #t "~1Tosc: #<oscillating-float @ #x~X>~%" (-> this osc))
(format #t "~1Tmax-value: ~f~%" (-> this max-value))
(format #t "~1Tmin-value: ~f~%" (-> this min-value))
(format #t "~1Telasticity: ~f~%" (-> this elasticity))
(format #t "~1Tstate: ~D~%" (-> this state))
(label cfg-4)
this
)
;; definition of type delayed-rand-vector
(deftype delayed-rand-vector (structure)
((min-time int32)
(max-time int32)
(xz-max float)
(y-max float)
(timer int32)
(start-time time-frame)
(value vector :inline)
)
(:methods
(delayed-rand-vector-method-9 () none)
(delayed-rand-vector-method-10 () none)
(delayed-rand-vector-method-11 () none)
(delayed-rand-vector-method-12 () none)
)
)
;; definition for method 3 of type delayed-rand-vector
(defmethod inspect ((this delayed-rand-vector))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'delayed-rand-vector)
(format #t "~1Tmin-time: ~D~%" (-> this min-time))
(format #t "~1Tmax-time: ~D~%" (-> this max-time))
(format #t "~1Txz-max: ~f~%" (-> this xz-max))
(format #t "~1Ty-max: ~f~%" (-> this y-max))
(format #t "~1Ttimer: ~D~%" (-> this timer))
(format #t "~1Tstart-time: ~D~%" (-> this start-time))
(format #t "~1Tvalue: #<vector @ #x~X>~%" (-> this value))
(label cfg-4)
this
)
;; definition of type oscillating-vector
(deftype oscillating-vector (structure)
((value vector :inline)
(target vector :inline)
(vel vector :inline)
(max-vel float)
(damping float)
(accel float)
)
(:methods
(oscillating-vector-method-9 () none)
(oscillating-vector-method-10 () none)
)
)
;; definition for method 3 of type oscillating-vector
(defmethod inspect ((this oscillating-vector))
(when (not this)
(set! this this)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" this 'oscillating-vector)
(format #t "~1Tvalue: #<vector @ #x~X>~%" (-> this value))
(format #t "~1Ttarget: #<vector @ #x~X>~%" (-> this target))
(format #t "~1Tvel: #<vector @ #x~X>~%" (-> this vel))
(format #t "~1Tmax-vel: ~f~%" (-> this max-vel))
(format #t "~1Tdamping: ~f~%" (-> this damping))
(format #t "~1Taccel: ~f~%" (-> this accel))
(label cfg-4)
this
)
;; failed to figure out what this is:
0