Archive/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project.git synced 2024-10-20 11:26:18 -04:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

[decomp] ramdisk, load-dgo and rpc-h (#496)

Browse source 
* decompile ramdisk load-dgo and rpc-h

* add a bunch of offline tests

* clang-format
This commit is contained in:
water111 2021-05-16 21:07:22 -04:00 committed by GitHub
parent b75a64fc29
commit ec412c7777
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
31 changed files with 5351 additions and 177 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

147
decompiler/config/all-types.gc
View file

@ -80,6 +80,22 @@
(define-extern mc-run (function none))
(define-extern mc-check-result (function int))
(defenum link-flag
:bitfield #t
:type int32
(output-load-msg 0)
(output-load-true-msg 1)
(execute-login 2)
(print-login 3)
(force-debug 4)
(fast-link 5)
)
(define-extern link-begin (function pointer (pointer uint8) int kheap link-flag int))
(define-extern rpc-call (function int uint uint uint int uint int uint))
(define-extern rpc-busy? (function int uint))
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; GCOMMON ;;;;;;;;;;;;;;;;;;;
@ -8504,6 +8520,11 @@
:flag-assert #x900000090
)
;;;; engine
(define-extern *background-draw-engine* engine)
(define-extern *camera-engine* engine)
(define-extern *debug-engine* engine)
;; res-h
(deftype res-tag (uint128)
@ -13147,15 +13168,31 @@
; )
; )
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; LOAD-DGO ;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
(defenum load-msg-result
:type uint16
:bitfield #f
(done 0)
(error 1)
(more 2)
(aborted 3)
(invalid 666)
)
;; load-dgo
(deftype load-dgo-msg (structure)
((rsvd uint16 :offset-assert 0)
(result uint16 :offset-assert 2)
(result load-msg-result :offset-assert 2)
(b1 uint32 :offset-assert 4)
(b2 uint32 :offset-assert 8)
(bt uint32 :offset-assert 12)
;(name uint128 :offset-assert 16)
(name uint8 16 :offset-assert 16)
(name uint128 :offset-assert 16)
(name-chars uint8 16 :offset 16)
(address uint32 :offset 4)
)
:method-count-assert 9
@ -13166,7 +13203,7 @@
;; load-dgo
(deftype load-chunk-msg (structure)
((rsvd uint16 :offset-assert 0)
(result uint16 :offset-assert 2)
(result load-msg-result :offset-assert 2)
(address pointer :offset-assert 4)
(section uint32 :offset-assert 8)
(maxlen uint32 :offset-assert 12)
@ -13182,23 +13219,51 @@
(deftype dgo-header (structure)
((length uint32 :offset-assert 0)
(rootname uint8 60 :offset-assert 4)
;; added
(data uint8 :dynamic :offset-assert 64)
)
:method-count-assert 9
:size-assert #x40
:flag-assert #x900000040
)
; ;; ramdisk
; (deftype ramdisk-rpc-fill (structure)
; ((rsvd1 int32 :offset-assert 0)
; (ee-id int32 :offset-assert 4)
; (rsvd2 UNKNOWN 2 :offset-assert 8)
; (filename uint128 :offset-assert 16)
; )
; :method-count-assert 9
; :size-assert #x20
; :flag-assert #x900000020
; )
(define-extern *load-dgo-rpc* rpc-buffer-pair)
(define-extern *load-str-rpc* rpc-buffer-pair)
(define-extern *play-str-rpc* rpc-buffer-pair)
(define-extern *load-str-lock* symbol)
(define-extern *que-str-lock* symbol)
(define-extern *dgo-name* string)
(define-extern str-load (function string int pointer int symbol))
(define-extern str-load-status (function (pointer int32) symbol))
(define-extern str-load-cancel (function none))
(define-extern str-play-async (function string pointer none))
(define-extern str-play-stop (function string none))
(define-extern str-play-queue (function string none))
(define-extern str-ambient-play (function string none))
(define-extern str-ambient-stop (function string none))
(define-extern dgo-load-begin (function string int int int load-dgo-msg))
(define-extern dgo-load-get-next (function (pointer symbol) pointer))
(define-extern dgo-load-continue (function pointer int))
(define-extern dgo-load-cancel (function none))
(define-extern find-temp-buffer (function int pointer))
(define-extern dgo-load-link (function dgo-header kheap symbol symbol symbol))
(define-extern destroy-mem (function (pointer uint32) (pointer uint32) none))
(define-extern string->sound-name (function string uint128))
(define-extern str-play-kick (function none))
(define-extern *dgo-time* uint)
;; ramdisk
(deftype ramdisk-rpc-fill (structure)
((rsvd1 int32 :offset-assert 0)
(ee-id int32 :offset-assert 4)
(rsvd2 int32 2 :offset-assert 8)
(filename uint128 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; ramdisk
(deftype ramdisk-rpc-load (structure)
@ -13225,6 +13290,11 @@
:flag-assert #x900000020
)
(define-extern *current-ramdisk-id* int)
(define-extern ramdisk-load (function int uint uint pointer int))
(define-extern *ramdisk-rpc* rpc-buffer-pair)
(define-extern ramdisk-sync (function none))
; ;; gsound
; (deftype sound-iop-info (basic)
; ((frame uint32 :offset-assert 16)
@ -33538,7 +33608,7 @@
(define-extern art-joint-anim type)
(define-extern joint-anim-compressed type)
(define-extern art-joint-geo type)
(define-extern new-dynamic-structure (function kheap type int structure)) ;; unknown type
(define-extern new-dynamic-structure (function symbol type int structure)) ;; unknown type
(define-extern merc-fragment-fp-data (function merc-fragment pointer))
(define-extern ripple-wave-set type)
(define-extern merc-ctrl type)
@ -33563,10 +33633,9 @@
(define-extern *merc-globals* symbol) ;; unknown type
(define-extern *matrix-engine* (array handle)) ;; unknown type
;;(define-extern camera-eng object) ;; unknown type
;;(define-extern *camera-engine* object) ;; unknown type
;;(define-extern *background-draw-engine* object) ;; unknown type
;;(define-extern draw object) ;; unknown type
;;(define-extern *debug-engine* object) ;; unknown type
(define-extern *res-key-string* string) ;; unknown type
(define-extern *res-static-buf* pointer) ;; unknown type
(define-extern part-group-pointer? function)
@ -33867,38 +33936,12 @@
;;(define-extern nav-max-users object) ;; unknown type
;;(define-extern nav-engine object) ;; unknown type
;;(define-extern nearest-y-threshold object) ;; unknown type
(define-extern dgo-load-begin (function int int int int int))
(define-extern dgo-load-continue function)
(define-extern destroy-mem function)
(define-extern str-load (function string int pointer int symbol))
(define-extern *load-str-rpc* rpc-buffer-pair) ;; unknown type
;;(define-extern *dgo-name* object) ;; unknown type
(define-extern str-ambient-play (function string none))
(define-extern *load-str-lock* symbol) ;; unknown type
(define-extern str-load-status (function (pointer int32) symbol))
(define-extern str-load-cancel (function none))
(define-extern str-play-queue (function string none))
(define-extern str-ambient-stop (function string none))
(define-extern dgo-load-get-next function)
(define-extern find-temp-buffer function)
(define-extern str-play-kick (function none))
(define-extern *load-dgo-rpc* rpc-buffer-pair) ;; unknown type
(define-extern *que-str-lock* symbol) ;; unknown type
(define-extern dgo-load-cancel function)
(define-extern dgo-load-link function)
;;(define-extern *dgo-time* object) ;; unknown type
(define-extern str-play-async (function string int none))
(define-extern str-play-stop (function string none))
(define-extern *play-str-rpc* rpc-buffer-pair) ;; unknown type
(define-extern string->sound-name function)
;;(define-extern complete object) ;; unknown type
;;(define-extern busy object) ;; unknown type
;;(define-extern link-begin object) ;; unknown type
;;(define-extern *current-ramdisk-id* object) ;; unknown type
(define-extern ramdisk-load function)
;;(define-extern *ramdisk-rpc* object) ;; unknown type
(define-extern ramdisk-sync function)
;;(define-extern ramdisk-rpc-fill object) ;; unknown type
(define-extern swap-sound-buffers function)
(define-extern sound-group-stop function)
(define-extern sound-set-ear-trans function)
@ -34820,9 +34863,9 @@
(define-extern save-boundary-cmd function)
(define-extern command-get-int function)
(define-extern check-boundary function)
(define-extern load-state-want-vis function)
(define-extern load-state-want-vis (function int none))
(define-extern add-boundary-shader function)
(define-extern load-state-want-levels function)
(define-extern load-state-want-levels (function int int none))
(define-extern lb-add-vtx-before function)
(define-extern draw-boundary-polygon function)
(define-extern load-boundary-from-template function)
@ -34840,7 +34883,7 @@
(define-extern lb-set-camera function)
(define-extern draw-boundary-cap function)
(define-extern lb-add function)
(define-extern load-state-want-display-level function)
(define-extern load-state-want-display-level (function int int none))
(define-extern render-boundary function)
(define-extern init-boundary-regs function)
(define-extern lb-del function)
@ -34956,7 +34999,7 @@
(define-extern level-update-after-load function)
(define-extern update-sound-banks function)
(define-extern add-bsp-drawable function)
;;(define-extern *print-login* object) ;; unknown type
(define-extern *print-login* symbol) ;; unknown type
;;(define-extern link-resume object) ;; unknown type
;;(define-extern display-self object) ;; unknown type
;;(define-extern loading-done object) ;; unknown type

4
decompiler/config/jak1_ntsc_black_label/label_types.jsonc
View file

@ -432,5 +432,9 @@
["L28", "level-load-info", true],
["L544", "level-load-info", true],
["L2", "pair", true]
],
"load-dgo": [
["L46", "uint64", true]
]
}

4
decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc
View file

@ -237,5 +237,9 @@
[144, "vector4s-3"],
[192, "vector"],
[208, "vector4s-3"]
],
"string->sound-name": [
[16, "qword"]
]
}

52
decompiler/config/jak1_ntsc_black_label/type_casts.jsonc
View file

@ -394,5 +394,57 @@
"(method 0 align-control)": [
[[8, 13], "t9", "(function object object)"],
[14, "v0", "align-control"]
],
"str-load": [
[[20, 36], "s2", "load-chunk-msg"]
],
"str-load-status":[
[[18, 28], "v1", "load-chunk-msg"]
],
"str-play-async": [
[[8, 16], "s4", "load-chunk-msg"]
],
"str-play-stop": [
[[7, 14], "s5", "load-chunk-msg"]
],
"str-play-queue": [
[[19, 27], "s5", "load-chunk-msg"]
],
"str-ambient-play": [
[[7, 15], "s5", "load-chunk-msg"]
],
"str-ambient-stop": [
[[7, 16], "s5", "load-chunk-msg"]
],
"dgo-load-begin": [
[[21, 40], "s2", "load-dgo-msg"]
],
"dgo-load-get-next": [
[[14, 31], "v1", "load-dgo-msg"]
],
"dgo-load-continue": [
[[5, 21], "gp", "load-dgo-msg"]
],
"string->sound-name": [
[[6, 8], "a1", "(pointer uint8)"]
],
"ramdisk-load": [
[[8, 12], "v1", "ramdisk-rpc-load"]
],
"(method 3 generic-tie-interp-point)": [
[15, "gp", "(pointer uint128)"]
]
}

79
decompiler/config/jak1_ntsc_black_label/var_names.jsonc
View file

@ -1579,5 +1579,84 @@
"(method 0 align-control)": {
"vars":{"v0-0": ["obj", "align-control"]}
},
"str-load": {
"args":["name", "chunk-id", "address", "len"],
"vars":{"s2-0":["cmd", "load-chunk-msg"]}
},
"str-load-status": {
"args":["length-out"],
"vars":{"v1-7":"response"}
},
"str-play-async": {
"args": ["name", "addr"],
"vars":{"s4-0":"cmd"}
},
"str-play-stop": {
"args": ["name"],
"vars":{"s5-0":"cmd"}
},
"str-play-queue": {
"args": ["name"],
"vars":{"s5-0":"cmd"}
},
"str-ambient-play": {
"args": ["name"],
"vars":{"s5-0":"cmd"}
},
"str-ambient-stop": {
"args": ["name"],
"vars":{"s5-0":"cmd"}
},
"string->sound-name": {
"args":["str"],
"vars":{"v1-0":"snd-name", "a1-0":["out-ptr", "(pointer uint8)"], "a2-0":"in-ptr"}
},
"dgo-load-begin": {
"args":["name", "buffer1", "buffer2", "current-heap"],
"vars":{"s2-0":"cmd"}
},
"dgo-load-get-next": {
"args":["last-object"],
"vars":{"gp-0":["load-location", "pointer"], "v1-5":"response"}
},
"dgo-load-continue": {
"args":["current-heap"],
"vars":{"gp-0":"cmd"}
},
"dgo-load-cancel": {
"vars":{"a2-0":"cmd"}
},
"find-temp-buffer": {
"args":["size"],
"vars":{"gp-0":"qwc"}
},
"dgo-load-link": {
"args":["obj-file", "heap", "print-login", "last-object"],
"vars":{"s4-0":"obj-data"}
},
"ramdisk-load": {
"args":["file-id", "offset", "length", "buffer"],
"vars":{"v1-1":"cmd"}
},
"show-mc-info": {
"args":["dma-buf"],
"vars":{"s5-0":"info", "s4-0":"slot-idx"}
}
}

4
game/kernel/kscheme.cpp
View file

@ -222,8 +222,8 @@ u64 new_structure(u32 heap, u32 type) {
/*!
* Allocate a structure with a dynamic size
*/
u64 new_dynamic_structure(u32 heap, u32 type, u32 size) {
return alloc_from_heap(heap, type, size);
u64 new_dynamic_structure(u32 heap_symbol, u32 type, u32 size) {
return alloc_from_heap(heap_symbol, type, size);
}
/*!

19
goal_src/engine/data/art-h.gc
View file

@ -59,20 +59,15 @@
)
)
(defmethod
new
joint-anim-frame
((allocation symbol) (type-to-make type) (arg0 int))
(defmethod new joint-anim-frame ((allocation symbol) (type-to-make type) (arg0 int))
(let ((v1-1 (max 0 (+ arg0 -2))))
(the-as
joint-anim-frame
(new-dynamic-structure
(the-as kheap allocation)
type-to-make
(the-as int (+ (-> type-to-make size) (the-as uint (* 48 v1-1))))
)
(the-as joint-anim-frame
(new-dynamic-structure
allocation
type-to-make
(the-as int (+ (-> type-to-make size) (the-as uint (* 48 v1-1)))))
)
)
)
)
(deftype joint-anim-compressed-hdr (structure)

8
goal_src/engine/gfx/time-of-day-h.gc
View file

@ -28,12 +28,8 @@
)
)
(define-extern *palette-fade-controls* palette-fade-controls)
(if (or (not *palette-fade-controls*) (zero? *palette-fade-controls*))
(set!
*palette-fade-controls*
(the-as palette-fade-controls (new 'global 'palette-fade-controls))
)
(define-perm *palette-fade-controls* palette-fade-controls
(new 'global 'palette-fade-controls)
)
(deftype time-of-day-proc (process)

413
goal_src/engine/load/load-dgo.gc
View file

@ -5,15 +5,33 @@
;; name in dgo: load-dgo
;; dgos: GAME, ENGINE
;;;;;;;;;;;;;;;;;;;;;;;;
;; OVERLORD messages
;;;;;;;;;;;;;;;;;;;;;;;;
;; status flag sent from OVERLORD about a DGO load.
(defenum load-msg-result
:type uint16
:bitfield #f
(done 0) ;; dgo fully loaded!
(error 1) ;; loading failed (file not found, etc)
(more 2) ;; more files exist!
(aborted 3) ;; status returned after a request to cancel.
(invalid 666) ;; invalid status indicating a communication error.
)
;; load command sent to the IOP to load a DGO.
;; The OVERLORD responds with the same message.
(deftype load-dgo-msg (structure)
((rsvd uint16 :offset-assert 0)
(result uint16 :offset-assert 2)
(b1 uint32 :offset-assert 4)
(b2 uint32 :offset-assert 8)
(bt uint32 :offset-assert 12)
;(name uint128 :offset-assert 16)
(name uint8 16 :offset-assert 16)
(address uint32 :offset 4)
((rsvd uint16 :offset-assert 0) ;; unused?
(result load-msg-result :offset-assert 2) ;; status from OVERLORD
(b1 uint32 :offset-assert 4) ;; EE -> OVERLORD, first temp load buffer
(b2 uint32 :offset-assert 8) ;; EE -> OVERLORD, second temp load buffer
(bt uint32 :offset-assert 12) ;; EE -> OVERLORD, location of heap
(name uint128 :offset-assert 16) ;; EE -> OVERLORD, name of file.
(name-chars uint8 16 :offset 16) ;; name of file (as chars)
(address uint32 :offset 4) ;; OVERLORD -> EE, location of loaded file.
)
:method-count-assert 9
:size-assert #x20
@ -31,14 +49,16 @@ struct RPC_Dgo_Cmd {
};
|#
;; load commmand/response for loading a chunk of a file.
;; It can either be an entire file, or a section of a STR file.
(deftype load-chunk-msg (structure)
((rsvd uint16 :offset-assert 0)
(result uint16 :offset-assert 2)
(address pointer :offset-assert 4)
(section uint32 :offset-assert 8)
(maxlen uint32 :offset-assert 12)
(id uint32 :offset 4)
(basename uint8 48 :offset-assert 16)
((rsvd uint16 :offset-assert 0) ;; unused?
(result load-msg-result :offset-assert 2) ;; only done or error.
(address pointer :offset-assert 4) ;; where to load to
(section uint32 :offset-assert 8) ;; chunk ID, or -1 for the whole file.
(maxlen uint32 :offset-assert 12) ;; maximum length to load.
(id uint32 :offset 4) ;; ? same as chunk
(basename uint8 48 :offset-assert 16) ;; name of file to load.
)
:method-count-assert 9
:size-assert #x40
@ -57,9 +77,12 @@ struct RPC_Str_Cmd {
};
|#
;; The header of a DGO file
(deftype dgo-header (structure)
((length uint32 :offset-assert 0)
((length uint32 :offset-assert 0) ;; number of object files contained.
(rootname uint8 60 :offset-assert 4)
;; added data field
(data uint8 :dynamic :offset-assert 64)
)
:method-count-assert 9
:size-assert #x40
@ -73,38 +96,52 @@ struct DgoHeader {
};
|#
;;;;;;;;;;;;;;;;;;;;;;;;;
;; RPC Buffer init
;;;;;;;;;;;;;;;;;;;;;;;;;
(define-extern *load-dgo-rpc* rpc-buffer-pair)
(when (= 0 (the int *load-dgo-rpc*))
;; we need to allocate the rpc buffers
(set! *load-dgo-rpc* (new 'global 'rpc-buffer-pair (the uint 32) (the uint 1) 3)) ;; todo, constants
(define *load-str-rpc* (new 'global 'rpc-buffer-pair (the uint 64) (the uint 1) 4)) ;; todo, constants
(define *play-str-rpc* (new 'global 'rpc-buffer-pair (the uint 64) (the uint 2) 5))
;; we have separate locks for queuing and loading.
(define *load-str-lock* '#f)
(define *que-str-lock* '#f)
(define *dgo-name* (new 'global 'string 64 (the string '#f)))
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; STR LOAD
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; load a file, or part of a chunked STR file.
(defun str-load ((name string) (chunk-id int) (address pointer) (len int))
"Begin a streaming load if possible!
We must be able to grab the lock, and no streaming load in progress.
Return if we actually start the load."
;; call method 13
(when (or (check-busy *load-str-rpc*)
*load-str-lock*
)
(return-from #f '#f)
)
;; check if safe to begin load.
(when (or (check-busy *load-str-rpc*) *load-str-lock*)
(return #f)
)
;; ok, we are good to start a load. begin by adding an element to the RPC buffer
(let ((cmd (the load-chunk-msg (add-element *load-str-rpc*))))
(set! (-> cmd result) 666)
(set! (-> cmd result) (load-msg-result invalid))
(set! (-> cmd address) address)
(set! (-> cmd section) chunk-id)
(set! (-> cmd maxlen) len)
(charp<-string (-> cmd basename) name)
;; and then calling with this element
(call *load-str-rpc* (the uint 0) (the pointer cmd) (the uint 32))
(set! *load-str-lock* '#t)
(set! *que-str-lock* '#t)
'#t
(set! *load-str-lock* #t)
(set! *que-str-lock* #t)
#t
)
)
@ -114,21 +151,313 @@ struct DgoHeader {
The 'error status indicates the load failed.
The 'complete status means the load is finished, and length-out contains the loaded length."
;; still going..
(if (check-busy *load-str-rpc*)
(return-from #f 'busy)
)
;; still going..
(if (check-busy *load-str-rpc*)
(return 'busy)
)
;; not busy, we can free the lock
(set! *load-str-lock* '#f)
(set! *que-str-lock* '#t)
;; grab the response
(let ((response (the load-chunk-msg (pop-last-received *load-str-rpc*))))
(if (= 1 (-> response result))
(return-from #f 'error)
)
;; no error!
(set! (-> length-out) (the int (-> response maxlen)))
'complete
;; not busy, we can free the lock
(set! *load-str-lock* #f)
;; also lock the queue. Not sure why?
(set! *que-str-lock* #t)
;; grab the response
(let ((response (the load-chunk-msg (pop-last-received *load-str-rpc*))))
(if (= (-> response result) (load-msg-result error))
(return 'error)
)
;; no error!
(set! (-> length-out) (the int (-> response maxlen)))
'complete
)
)
(defun str-load-cancel ()
"Cancel a str load. This doesn't actually tell the OVERLORD to stop, it just frees the lock."
(set! *load-str-lock* #f)
;; and locks the queue?
(set! *que-str-lock* #t)
(none)
)
;;;;;;;;;;;;;;;;;;;;;;;;;
;; STR PLAY
;;;;;;;;;;;;;;;;;;;;;;;;;
;; unknown. I think related to playing cutscene stuff?
(defun str-play-async ((name string) (addr pointer))
"Queue a play cmd to do... something?
Locks the queue, doesn't check other locks"
(set! *que-str-lock* #t)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(charp<-string (-> cmd basename) name)
;; might be an id?
(set! (-> cmd address) addr)
;; probably using a different enum here
(set! (-> cmd result) (load-msg-result done))
)
(none)
)
(defun str-play-stop ((name string))
"Queue command to stop playing."
(set! *que-str-lock* #t)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
;; not sure why we need a name to stop?
(charp<-string (-> cmd basename) name)
;; might be wrong enum here
(set! (-> cmd result) (load-msg-result error))
)
(none)
)
(defun str-play-queue ((name string))
"Queue a command to do something"
(when (and (not (check-busy *play-str-rpc*))
(not *load-str-lock*)
(not *que-str-lock*)
)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(charp<-string (-> cmd basename) name)
(set! (-> cmd result) (load-msg-result more))
)
)
(set! *que-str-lock* #f)
(none)
)
(defun str-ambient-play ((name string))
"Queue a command to do something"
(set! *que-str-lock* #t)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(set! (-> cmd basename 0) (the-as uint 36)) ;; a '$' char
(charp<-string (&-> cmd basename 1) name)
(set! (-> cmd result) (load-msg-result done))
)
(none)
)
(defun str-ambient-stop ((name string))
(set! *que-str-lock* #t)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(set! (-> cmd basename 0) (the-as uint 36)) ;; a '$' char
(charp<-string (&-> cmd basename 1) name)
(set! (-> cmd result) (load-msg-result error))
)
(none)
)
(defun str-play-kick ()
"Call str RPC if we aren't busy"
;; is written with an empty body for the first case.
(cond
((check-busy *play-str-rpc*)
)
(else
(call *play-str-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
)
)
(none)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; DGO LOAD and LINK
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun string->sound-name! ((out (pointer uint128)) (in string))
"This function was added as a temporary workaround for not having
uint128 return values in OpenGOAL yet."
(set! (-> out) (the uint128 0))
(let ((out-ptr (the (pointer uint8) out))
(in-ptr (-> in data)))
(while (and (nonzero? (-> in-ptr))
(< (&- in-ptr (-> in data)) 15))
(set! (-> out-ptr) (-> in-ptr))
(&+! out-ptr 1)
(&+! in-ptr 1)
)
)
)
(define *dgo-time* (the-as uint 0))
(defun dgo-load-begin ((name string) (buffer1 int) (buffer2 int) (current-heap int))
"Send a DGO load RPC!"
;; remember when we started
(set! *dgo-time* (-> *display* real-integral-frame-counter))
(format 0 "Starting level load clock~%")
;; flush pending RPC
(sync *load-dgo-rpc* #t)
;; grab a new command from the RCP buffer
(let ((cmd (the-as load-dgo-msg (add-element *load-dgo-rpc*))))
;; set parameters
(set! (-> cmd result) (load-msg-result invalid))
(set! (-> cmd b1) (the-as uint buffer1))
(set! (-> cmd b2) (the-as uint buffer2))
(set! (-> cmd bt) (the-as uint current-heap))
;; modified due to OpenGOAL not supporting uint128 return values yet
;;(set! (-> cmd name) (string->sound-name name))
(string->sound-name! (&-> cmd name) name)
;; call now!
(call *load-dgo-rpc* (the-as uint 0) (the-as pointer cmd) (the-as uint 32))
cmd
)
)
(defun dgo-load-get-next ((last-object (pointer symbol)))
"Check if the currently loading object is done.
Will set the last-object flag depending on if there is more.
Returns #f if it hasn't loaded yet and the address otherwise"
(set! (-> last-object 0) #t)
(let ((load-location (the-as pointer #f)))
;; see if RPC is done
(when (not (check-busy *load-dgo-rpc*))
;; it is, try to get a response, if there is a new one.
(let ((response (the-as load-dgo-msg (pop-last-received *load-dgo-rpc*))))
(when response
;; get load location
(if (or (= (-> response result) (load-msg-result done)) (= (-> response result) (load-msg-result more)))
;; success! set load location to the location the IOP loaded to.
(set! load-location (the-as pointer (-> response b1)))
)
;; set more flag
(if (= (-> response result) (load-msg-result more))
(set! (-> last-object 0) #f)
)
;; if we're done loading, print the load time.
;; note that this does not include linking/setup of the
;; final object in the level which may take a significant amount of time
(if (= (-> response result) (load-msg-result done))
;; this assumes 60 fps!
(format 0 "Elapsed time for level = ~Fs~%"
(* 0.016666668 (the float (- (-> *display* real-integral-frame-counter) *dgo-time*)))
)
)
)
)
)
load-location
)
)
(defun dgo-load-continue ((current-heap pointer))
"Send a command to to the IOP to continue loading a DGO"
(let ((cmd (the-as load-dgo-msg (add-element *load-dgo-rpc*))))
(set! (-> cmd result) (load-msg-result invalid))
(set! (-> cmd b1) (the-as uint 0))
(set! (-> cmd b2) (the-as uint 0))
(set! (-> cmd bt) (the-as uint current-heap))
(set! (-> cmd name) (the-as uint128 0))
(call *load-dgo-rpc* (the-as uint 1) (the-as pointer cmd) (the-as uint 32))
(the-as int cmd)
)
)
(defun dgo-load-cancel ()
"Send a command to the IOP to cancel loading a DGO.
NOTE: this _might_ stall for a long time (multiple frames)
if you call it while an object is currently being loaded.
I believe this is only good to call if you do it after
dgo-load-get-next and before dgo-load-continue"
(sync *load-dgo-rpc* #t)
(let ((cmd (add-element *load-dgo-rpc*)))
(call *load-dgo-rpc* (the-as uint 2) cmd (the-as uint 32))
)
(none)
)
(defun find-temp-buffer ((size int))
"A terrible function to find some temporary space in the DMA system.
It is unused, thankfully"
;; it checks the same thing twice.
(let ((qwc (+ (/ size 16) 2)))
(the-as pointer
(cond
((< (the-as uint qwc)
(the-as uint (dma-buffer-free (-> *display* frames (-> *display* on-screen) frame global-buf)))
)
(logand -16 (the-as int (&+ (-> *display* frames (-> *display* on-screen) frame global-buf base) 15)))
)
((< (the-as uint qwc)
(the-as uint (dma-buffer-free (-> *display* frames (-> *display* on-screen) frame global-buf)))
)
(logand -16 (the-as int (&+ (-> *display* frames (-> *display* on-screen) frame global-buf base) 15)))
)
)
)
)
)
(defenum link-flag
:bitfield #t
:type int32
(output-load-msg 0)
(output-load-true-msg 1)
(execute-login 2)
(print-login 3)
(force-debug 4)
(fast-link 5)
)
; (link-flag output-load-msg
; output-load-true-msg
; execute-login
; fast-link)
(defun dgo-load-link ((obj-file dgo-header) (heap kheap) (print-login symbol) (last-object symbol))
"Begin linking an object from a DGO.
The obj-file argument should be the thing returned from dgo-load-get-next"
(let ((obj-data (-> obj-file data)))
;; first, check to see if we ran off the end of the heap.
;; ideally you'd check this _before_ loading the file
(if (>= (the-as int (&+ obj-data (-> obj-file length))) (the-as int (-> heap top-base)))
;; just print an error, and continue...
(format 0 "ERROR: -----> dgo file header #x~X has overrun heap #x~X by ~D bytes. This is very bad!~%"
obj-file
heap
(&- (&+ obj-data (-> obj-file length)) (the-as uint (-> heap top-base)))
)
)
;; last object should be loaded on top of the heap.
;; until this link completes, the heap is in a very strange state.
(if last-object
(format 0 "NOTICE: loaded ~g, ~D bytes (~f K) at top ~D~%"
(-> obj-file rootname)
(-> obj-file length)
(* 0.0009765625 (the float (-> obj-file length)))
(&- (&+ obj-data (-> obj-file length)) (the-as uint (-> heap base)))
)
)
;; store the dgo name
(string<-charp (clear *dgo-name*) (-> obj-file rootname))
(nonzero?
(link-begin obj-data (-> *dgo-name* data) (the-as int (-> obj-file length)) heap
(if print-login
(link-flag output-load-msg output-load-true-msg execute-login fast-link print-login)
(link-flag output-load-msg output-load-true-msg execute-login fast-link)
)
)
)
)
)
)
(defun destroy-mem ((arg0 (pointer uint32)) (arg1 (pointer uint32)))
"Overwrite memory from arg0 to arg1"
(while (< (the-as int arg0) (the-as int arg1))
(set! (-> arg0 0) #xffffffff)
(set! arg0 (&-> arg0 1))
)
(none)
)

64
goal_src/engine/load/ramdisk.gc
View file

@ -5,3 +5,67 @@
;; name in dgo: ramdisk
;; dgos: GAME, ENGINE
;; see game/overlord/ramdisk.cpp
;; unlike most other loads, ramdisk actually uses the response buffer of the RPC
;; to send the data.
;; command to load something into the OVERLORD RAMDISK from the DVD
;; use with fno = 1
(deftype ramdisk-rpc-fill (structure)
((rsvd1 int32 :offset-assert 0)
(ee-id int32 :offset-assert 4)
(rsvd2 int32 2 :offset-assert 8)
(filename uint128 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; get data in ramdisk on EE.
(deftype ramdisk-rpc-load (structure)
((rsvd int32 :offset-assert 0)
(ee-id int32 :offset-assert 4)
(offset uint32 :offset-assert 8)
(length uint32 :offset-assert 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; load file directly to EE.
;; this seems very similar to some functionality in STR.
(deftype ramdisk-rpc-load-to-ee (structure)
((rsvd int32 :offset-assert 0)
(addr int32 :offset-assert 4)
(offset int32 :offset-assert 8)
(length int32 :offset-assert 12)
(filename uint128 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; allocate the ramdisk RPC buffer
(define *ramdisk-rpc* (new 'global 'rpc-buffer-pair (the-as uint 32) (the-as uint 1) 2))
(define *current-ramdisk-id* 0)
(defun ramdisk-load ((file-id int) (offset uint) (length uint) (buffer pointer))
"Helper to grab load from ramdisk to ee"
(let ((cmd (the-as ramdisk-rpc-load (add-element *ramdisk-rpc*))))
(set! (-> cmd offset) offset)
(set! (-> cmd ee-id) file-id)
(set! (-> cmd length) length)
)
(call *ramdisk-rpc* (the-as uint 0) buffer length)
0
)
(defun ramdisk-sync ()
"Wait for ramdisk RPC to complete."
(sync *ramdisk-rpc* #t)
(none)
)

38
goal_src/engine/ps2/memcard-h.gc
View file

@ -63,6 +63,38 @@
v0-0
)
;; TODO - show-mc-info - failed to decompile
;; WARN: Type Propagation failed: Failed to find a stack variable at offset 16
;; WARN: Type Propagation failed: Type analysis failed
(defun show-mc-info ((dma-buf dma-buffer))
"Print mc info to the screen."
(let ((info (new 'stack-no-clear 'mc-slot-info)))
(dotimes (slot-idx 2)
(mc-get-slot-info slot-idx)
(cond
((zero? (-> info known))
(format (clear *temp-string*) "SLOT ~D: EXAMINING SLOT~%" slot-idx)
)
((zero? (-> info handle))
(format (clear *temp-string*) "SLOT ~D: NO CARD~%" slot-idx)
)
((zero? (-> info formatted))
(format (clear *temp-string*) "SLOT ~D: CARD [~D] : NOT FORMATTED~%" slot-idx (-> info handle))
)
((zero? (-> info inited))
(format (clear *temp-string*) "SLOT ~D: CARD [~D] : NO FILE [~D/~D]~%"
slot-idx (-> info handle) (-> info mem-required) (-> info mem-actual))
)
(else
(format (clear *temp-string*) "SLOT ~D: CARD [~D] : " slot-idx (-> info handle))
(format *temp-string* "SAVES ~D ~D ~D ~D : LAST ~D~%"
(-> info file 0 present)
(-> info file 1 present)
(-> info file 2 present)
(-> info file 3 present)
(-> info last-file)
)
)
)
(draw-string-xy *temp-string* dma-buf 32 (+ (* 12 slot-idx) 8) 3 1)
)
)
(none)
)

21
goal_src/kernel-defs.gc
View file

@ -74,6 +74,18 @@
(top 13)
)
(defenum link-flag
:bitfield #t
:type int32
(output-load-msg 0)
(output-load-true-msg 1)
(execute-login 2)
(print-login 3)
(force-debug 4)
(fast-link 5)
)
(define-extern string->symbol (function string symbol))
(define-extern print (function object object))
(define-extern inspect (function object object))
@ -83,11 +95,11 @@
(define-extern _format (function _varargs_ object))
(define-extern malloc (function symbol int pointer))
(define-extern kmalloc (function kheap int kmalloc-flags string pointer))
(define-extern new-dynamic-structure (function kheap type int structure))
(define-extern new-dynamic-structure (function symbol type int structure))
(define-extern method-set! (function type int function none)) ;; may actually return function.
(define-extern link (function pointer pointer int kheap int pointer))
(define-extern dgo-load (function string kheap int int none))
(define-extern link-begin (function pointer string int kheap int int))
(define-extern link-begin (function pointer (pointer uint8) int kheap link-flag int))
(define-extern link-resume (function int))
(define-extern mc-run (function none))
;; mc-format
@ -95,8 +107,11 @@
;; mc-create-file
;; mc-save
;; mc-load
(declare-type mc-slot-info structure)
(define-extern mc-sync (function int))
(define-extern mc-get-slot-info (function int mc-slot-info))
(define-extern mc-check-result (function int))
;; mc-get-slot-info
;; mc-makefile
;; kset-language

53
test/decompiler/reference/all_forward_declarations.gc
View file

@ -482,6 +482,17 @@
:flag-assert #x900000010
)
(deftype plane (vector)
((a float :offset 0)
(b float :offset 4)
(c float :offset 8)
(d float :offset 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
(deftype attack-info (structure)
((trans vector :inline :offset-assert 0)
(vector vector :inline :offset-assert 16)
@ -589,6 +600,48 @@
(define-extern sprite-distorter-generate-tables (function none))
(defenum load-msg-result
:type uint16
:bitfield #f
(done 0)
(error 1)
(more 2)
(aborted 3)
(invalid 666)
)
(declare-type rpc-buffer-pair basic)
(define-extern string->sound-name (function string uint128))
(define-extern *dgo-name* string)
(define-extern *load-dgo-rpc* rpc-buffer-pair)
(define-extern *load-str-rpc* rpc-buffer-pair)
(define-extern *play-str-rpc* rpc-buffer-pair)
(define-extern *load-str-lock* symbol)
(define-extern *que-str-lock* symbol)
(define-extern get-video-mode (function symbol))
(define-extern draw-string-xy (function string dma-buffer int int int int none))
(declare-type game-info basic)
(define-extern *game-info* game-info)
;; shadow-cpu
(deftype shadow-settings (structure)
((center vector :inline :offset-assert 0)
(flags int32 :offset 12)
(shadow-dir vector :inline :offset-assert 16)
(dist-to-locus float :offset 28)
(bot-plane plane :inline :offset-assert 32)
(top-plane plane :inline :offset-assert 48)
(fade-dist float :offset-assert 64)
(fade-start float :offset-assert 68)
(dummy-2 int32 :offset-assert 72)
(dummy-3 int32 :offset-assert 76)
)
:method-count-assert 9
:size-assert #x50
:flag-assert #x900000050
)
(defmacro init-vf0-vector ()
"Initializes the VF0 vector which is a constant vector in the VU set to <0,0,0,1>"
`(.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))

234
test/decompiler/reference/engine/anim/bones-h_REF.gc Normal file
View file

@ -0,0 +1,234 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type bone-buffer
(deftype bone-buffer (structure)
((joint joint-anim-compressed-hdr 16 :inline :offset-assert 0)
(bone bone 16 :inline :offset-assert 1024)
(_pad uint8 2048 :offset-assert 2560)
)
:method-count-assert 9
:size-assert #x1200
:flag-assert #x900001200
)
;; definition for method 3 of type bone-buffer
(defmethod inspect bone-buffer ((obj bone-buffer))
(format #t "[~8x] ~A~%" obj 'bone-buffer)
(format #t "~Tjoint[16] @ #x~X~%" (-> obj joint))
(format #t "~Tbone[16] @ #x~X~%" (-> obj bone))
(format #t "~Toutput[16] @ #x~X~%" (-> obj _pad))
obj
)
;; definition of type bone-layout
(deftype bone-layout (structure)
((joint joint 2 :offset-assert 0)
(bone bone 2 :offset-assert 8)
(data uint16 8 :offset 0)
(output uint32 2 :offset-assert 16)
(cache uint32 2 :offset-assert 24)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type bone-layout
(defmethod inspect bone-layout ((obj bone-layout))
(format #t "[~8x] ~A~%" obj 'bone-layout)
(format #t "~Tdata[8] @ #x~X~%" (-> obj joint))
(format #t "~Tjoint[2] @ #x~X~%" (-> obj joint))
(format #t "~Tbone[2] @ #x~X~%" (-> obj bone))
(format #t "~Toutput[2] @ #x~X~%" (-> obj output))
(format #t "~Tcache[2] @ #x~X~%" (-> obj cache))
obj
)
;; definition of type bone-regs
(deftype bone-regs (structure)
((joint-ptr (pointer joint) :offset-assert 0)
(bone-ptr (pointer bone) :offset-assert 4)
(num-bones uint32 :offset-assert 8)
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type bone-regs
(defmethod inspect bone-regs ((obj bone-regs))
(format #t "[~8x] ~A~%" obj 'bone-regs)
(format #t "~Tjoint-ptr: #x~X~%" (-> obj joint-ptr))
(format #t "~Tbone-ptr: #x~X~%" (-> obj bone-ptr))
(format #t "~Tnum-bones: ~D~%" (-> obj num-bones))
obj
)
;; definition of type bone-work
(deftype bone-work (structure)
((layout bone-layout :inline :offset-assert 0)
(bounds sphere :inline :offset-assert 32)
(lights vu-lights :inline :offset-assert 48)
(distance vector :inline :offset-assert 160)
(next-tag dma-packet :inline :offset-assert 176)
(dma-buf dma-buffer :offset-assert 192)
(sink-group basic :offset-assert 196)
(next-pris dma-packet :offset-assert 200)
(next-merc dma-packet :offset-assert 204)
(wait-count uint32 :offset-assert 208)
(in-count uint32 :offset-assert 212)
(sp-size uint32 :offset-assert 216)
(sp-bufnum uint32 :offset-assert 220)
(regs bone-regs :inline :offset-assert 224)
)
:method-count-assert 9
:size-assert #xec
:flag-assert #x9000000ec
)
;; definition for method 3 of type bone-work
(defmethod inspect bone-work ((obj bone-work))
(format #t "[~8x] ~A~%" obj 'bone-work)
(format #t "~Tlayout: #<bone-layout @ #x~X>~%" (-> obj layout))
(format #t "~Tbounds: #<sphere @ #x~X>~%" (-> obj bounds))
(format #t "~Tlights: #<vu-lights @ #x~X>~%" (-> obj lights))
(format #t "~Tdistance: #<vector @ #x~X>~%" (-> obj distance))
(format #t "~Tnext-tag: #<dma-packet @ #x~X>~%" (-> obj next-tag))
(format #t "~Tdma-buf: ~A~%" (-> obj dma-buf))
(format #t "~Tsink-group: ~A~%" (-> obj sink-group))
(format #t "~Tnext-pris: #<dma-packet @ #x~X>~%" (-> obj next-pris))
(format #t "~Tnext-merc: #<dma-packet @ #x~X>~%" (-> obj next-merc))
(format #t "~Twait-count: ~D~%" (-> obj wait-count))
(format #t "~Tin-count: ~D~%" (-> obj in-count))
(format #t "~Tsp-size: ~D~%" (-> obj sp-size))
(format #t "~Tsp-bufnum: ~D~%" (-> obj sp-bufnum))
(format #t "~Tregs: #<bone-regs @ #x~X>~%" (-> obj regs))
obj
)
;; definition of type bone-debug
(deftype bone-debug (structure)
((time-ctr uint32 :offset-assert 0)
(timing uint32 360 :offset-assert 4)
)
:method-count-assert 9
:size-assert #x5a4
:flag-assert #x9000005a4
)
;; definition for method 3 of type bone-debug
(defmethod inspect bone-debug ((obj bone-debug))
(format #t "[~8x] ~A~%" obj 'bone-debug)
(format #t "~Ttime-ctr: ~D~%" (-> obj time-ctr))
(format #t "~Ttiming[360] @ #x~X~%" (-> obj timing))
obj
)
;; definition of type bone-memory
(deftype bone-memory (structure)
((work bone-work :inline :offset-assert 0)
(buffer bone-buffer 2 :inline :offset-assert 240)
(dma-list dma-packet :inline :offset 240)
)
:method-count-assert 9
:size-assert #x24f0
:flag-assert #x9000024f0
)
;; definition for method 3 of type bone-memory
(defmethod inspect bone-memory ((obj bone-memory))
(format #t "[~8x] ~A~%" obj 'bone-memory)
(format #t "~Twork: #<bone-work @ #x~X>~%" (-> obj work))
(format #t "~Tbuffer[2] @ #x~X~%" (-> obj buffer))
(format #t "~Tdma-list: #<dma-packet @ #x~X>~%" (-> obj buffer))
obj
)
;; definition for function invalidate-cache-line
;; WARN: Unsupported inline assembly instruction kind - [sync.l]
;; WARN: Unsupported inline assembly instruction kind - [cache dxwbin a0, 0]
;; WARN: Unsupported inline assembly instruction kind - [sync.l]
;; WARN: Unsupported inline assembly instruction kind - [cache dxwbin a0, 1]
;; WARN: Unsupported inline assembly instruction kind - [sync.l]
(defun invalidate-cache-line ((arg0 pointer))
(.sync.l)
(.cache dxwbin arg0 0)
(.sync.l)
(.cache dxwbin arg0 1)
(.sync.l)
0
)
;; definition of type merc-globals
(deftype merc-globals (structure)
((first uint32 :offset-assert 0)
(next uint32 :offset-assert 4)
(sink basic :offset-assert 8)
)
:allow-misaligned :method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type merc-globals
(defmethod inspect merc-globals ((obj merc-globals))
(format #t "[~8x] ~A~%" obj 'merc-globals)
(format #t "~Tfirst: #x~X~%" (-> obj first))
(format #t "~Tnext: #x~X~%" (-> obj next))
(format #t "~Tsink: ~A~%" (-> obj sink))
obj
)
;; definition of type merc-global-array
(deftype merc-global-array (structure)
((count uint32 :offset-assert 0)
(globals merc-globals 8 :inline :offset-assert 4)
)
:method-count-assert 9
:size-assert #x84
:flag-assert #x900000084
)
;; definition for method 3 of type merc-global-array
(defmethod inspect merc-global-array ((obj merc-global-array))
(format #t "[~8x] ~A~%" obj 'merc-global-array)
(format #t "~Tcount: ~D~%" (-> obj count))
(format #t "~Tglobals[8] @ #x~X~%" (-> obj globals))
obj
)
;; definition for symbol *merc-globals*, type symbol
(define *merc-globals* #f)
;; definition of type shadow-dma-packet
(deftype shadow-dma-packet (structure)
((tag generic-merc-tag :inline :offset-assert 0)
(settings shadow-settings :inline :offset-assert 16)
(geo-ref dma-packet :inline :offset-assert 96)
(mtx-ref dma-packet :inline :offset-assert 112)
(end-tag dma-packet :inline :offset-assert 128)
)
:method-count-assert 9
:size-assert #x90
:flag-assert #x900000090
)
;; definition for method 3 of type shadow-dma-packet
(defmethod inspect shadow-dma-packet ((obj shadow-dma-packet))
(format #t "[~8x] ~A~%" obj 'shadow-dma-packet)
(format #t "~Ttag: #<generic-merc-tag @ #x~X>~%" (-> obj tag))
(format #t "~Tsettings: #<shadow-settings @ #x~X>~%" (-> obj settings))
(format #t "~Tgeo-ref: #<dma-packet @ #x~X>~%" (-> obj geo-ref))
(format #t "~Tmtx-ref: #<dma-packet @ #x~X>~%" (-> obj mtx-ref))
(format #t "~Tend-tag: #<dma-packet @ #x~X>~%" (-> obj end-tag))
obj
)
;; failed to figure out what this is:
(let ((v0-9 0))
)

200
test/decompiler/reference/engine/anim/joint-h_REF.gc Normal file
View file

@ -0,0 +1,200 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type joint-control-channel
(deftype joint-control-channel (structure)
((parent basic :offset-assert 0)
(command basic :offset-assert 4)
(frame-interp float :offset-assert 8)
(frame-group basic :offset-assert 12)
(frame-num float :offset-assert 16)
(num-func basic :offset-assert 20)
(param uint32 2 :offset-assert 24)
(group-sub-index int16 :offset-assert 32)
(group-size int16 :offset-assert 34)
(dist float :offset-assert 36)
(eval-time uint32 :offset-assert 40)
(inspector-amount float :offset-assert 44)
)
:method-count-assert 10
:size-assert #x30
:flag-assert #xa00000030
(:methods
(dummy-9 () none 9)
)
)
;; definition for method 3 of type joint-control-channel
(defmethod inspect joint-control-channel ((obj joint-control-channel))
(format #t "[~8x] ~A~%" obj 'joint-control-channel)
(format #t "~Tparent: ~A~%" (-> obj parent))
(format #t "~Tcommand: ~A~%" (-> obj command))
(format #t "~Tframe-interp: ~f~%" (-> obj frame-interp))
(format #t "~Tframe-group: ~A~%" (-> obj frame-group))
(format #t "~Tframe-num: ~f~%" (-> obj frame-num))
(format #t "~Tnum-func: ~A~%" (-> obj num-func))
(format #t "~Tparam[2] @ #x~X~%" (-> obj param))
(format #t "~Tgroup-sub-index: ~D~%" (-> obj group-sub-index))
(format #t "~Tgroup-size: ~D~%" (-> obj group-size))
(format #t "~Tdist: (meters ~m)~%" (-> obj dist))
(format #t "~Teval-time: ~D~%" (-> obj eval-time))
(format #t "~Tinspector-amount: ~f~%" (-> obj inspector-amount))
obj
)
;; definition of type joint-control
(deftype joint-control (basic)
((status uint16 :offset-assert 4)
(allocated-length int16 :offset-assert 6)
(root-channel uint32 :offset 16)
(blend-index int32 :offset-assert 20)
(active-channels int32 :offset-assert 24)
(generate-frame-function basic :offset-assert 28)
(prebind-function basic :offset-assert 32)
(postbind-function basic :offset-assert 36)
(effect basic :offset-assert 40)
(channel joint-control-channel 3 :inline :offset-assert 48)
(frame-group0 basic :offset 60)
(frame-num0 float :offset 64)
(frame-interp0 float :offset 56)
(frame-group1 basic :offset 108)
(frame-num1 float :offset 112)
(frame-interp1 float :offset 104)
(frame-group2 basic :offset 156)
(frame-num2 float :offset 160)
(frame-interp2 float :offset 152)
)
:method-count-assert 11
:size-assert #xc0
:flag-assert #xb000000c0
(:methods
(dummy-9 () none 9)
(dummy-10 () none 10)
)
)
;; definition for method 3 of type joint-control
(defmethod inspect joint-control ((obj joint-control))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tstatus: ~D~%" (-> obj status))
(format #t "~Tallocated-length: ~D~%" (-> obj allocated-length))
(format #t "~Troot-channel: #x~X~%" (-> obj root-channel))
(format #t "~Tblend-index: ~D~%" (-> obj blend-index))
(format #t "~Tactive-channels: ~D~%" (-> obj active-channels))
(format #t "~Tgenerate-frame-function: ~A~%" (-> obj generate-frame-function))
(format #t "~Tprebind-function: ~A~%" (-> obj prebind-function))
(format #t "~Tpostbind-function: ~A~%" (-> obj postbind-function))
(format #t "~Teffect: ~A~%" (-> obj effect))
(format #t "~Tchannel[0] @ #x~X~%" (-> obj channel))
(format #t "~Tframe-group0: ~A~%" (-> obj channel 0 frame-group))
(format #t "~Tframe-num0: ~f~%" (-> obj channel 0 frame-num))
(format #t "~Tframe-interp0: ~f~%" (-> obj channel 0 frame-interp))
(format #t "~Tframe-group1: ~A~%" (-> obj channel 1 frame-group))
(format #t "~Tframe-num1: ~f~%" (-> obj channel 1 frame-num))
(format #t "~Tframe-interp1: ~f~%" (-> obj channel 1 frame-interp))
(format #t "~Tframe-group2: ~A~%" (-> obj channel 2 frame-group))
(format #t "~Tframe-num2: ~f~%" (-> obj channel 2 frame-num))
(format #t "~Tframe-interp2: ~f~%" (-> obj channel 2 frame-interp))
obj
)
;; definition of type matrix-stack
(deftype matrix-stack (structure)
((top matrix :offset-assert 0)
(data matrix 24 :inline :offset-assert 16)
)
:method-count-assert 9
:size-assert #x610
:flag-assert #x900000610
)
;; definition for method 3 of type matrix-stack
(defmethod inspect matrix-stack ((obj matrix-stack))
(format #t "[~8x] ~A~%" obj 'matrix-stack)
(format #t "~Ttop: #<matrix @ #x~X>~%" (-> obj top))
(format #t "~Tdata[24] @ #x~X~%" (-> obj data))
obj
)
;; definition of type channel-upload-info
(deftype channel-upload-info (structure)
((fixed joint-anim-compressed-fixed :offset-assert 0)
(fixed-qwc int32 :offset-assert 4)
(frame joint-anim-compressed-frame :offset-assert 8)
(frame-qwc int32 :offset-assert 12)
(amount float :offset-assert 16)
(interp float :offset-assert 20)
)
:pack-me
:method-count-assert 9
:size-assert #x18
:flag-assert #x900000018
)
;; definition for method 3 of type channel-upload-info
(defmethod inspect channel-upload-info ((obj channel-upload-info))
(format #t "[~8x] ~A~%" obj 'channel-upload-info)
(format #t "~Tfixed: #<joint-anim-compressed-fixed @ #x~X>~%" (-> obj fixed))
(format #t "~Tfixed-qwc: ~D~%" (-> obj fixed-qwc))
(format #t "~Tframe: #<joint-anim-compressed-frame @ #x~X>~%" (-> obj frame))
(format #t "~Tframe-qwc: ~D~%" (-> obj frame-qwc))
(format #t "~Tamount: ~f~%" (-> obj amount))
(format #t "~Tinterp: ~f~%" (-> obj interp))
obj
)
;; definition of type joint-work
(deftype joint-work (structure)
((temp-mtx matrix :inline :offset-assert 0)
(joint-stack matrix-stack :inline :offset-assert 64)
(fix-jmp-table uint32 16 :offset-assert 1616)
(frm-jmp-table uint32 16 :offset-assert 1680)
(pair-jmp-table uint32 16 :offset-assert 1744)
(uploads channel-upload-info 24 :inline :offset-assert 1808)
(num-uploads int32 :offset-assert 2384)
(mtx-acc matrix 2 :inline :offset-assert 2400)
(tq-acc transformq 100 :inline :offset-assert 2528)
(jacp-hdr joint-anim-compressed-hdr :inline :offset-assert 7328)
(fixed-data joint-anim-compressed-fixed :inline :offset-assert 7392)
(frame-data joint-anim-compressed-frame 2 :inline :offset-assert 9600)
)
:method-count-assert 9
:size-assert #x3640
:flag-assert #x900003640
)
;; definition for method 3 of type joint-work
(defmethod inspect joint-work ((obj joint-work))
(format #t "[~8x] ~A~%" obj 'joint-work)
(format #t "~Ttemp-mtx: #<matrix @ #x~X>~%" (-> obj temp-mtx))
(format #t "~Tjoint-stack: #<matrix-stack @ #x~X>~%" (-> obj joint-stack))
(format #t "~Tfix-jmp-table[16] @ #x~X~%" (-> obj fix-jmp-table))
(format #t "~Tfrm-jmp-table[16] @ #x~X~%" (-> obj frm-jmp-table))
(format #t "~Tpair-jmp-table[16] @ #x~X~%" (-> obj pair-jmp-table))
(format #t "~Tuploads[24] @ #x~X~%" (-> obj uploads))
(format #t "~Tnum-uploads: ~D~%" (-> obj num-uploads))
(format #t "~Tmtx-acc[2] @ #x~X~%" (-> obj mtx-acc))
(format #t "~Ttq-acc[100] @ #x~X~%" (-> obj tq-acc))
(format
#t
"~Tjacp-hdr: #<joint-anim-compressed-hdr @ #x~X>~%"
(-> obj jacp-hdr)
)
(format
#t
"~Tfixed-data: #<joint-anim-compressed-fixed @ #x~X>~%"
(-> obj fixed-data)
)
(format #t "~Tframe-data[2] @ #x~X~%" (-> obj frame-data))
(format #t "~Tflatten-array[576] @ #x~X~%" (-> obj mtx-acc))
(format #t "~Tflattened[24] @ #x~X~%" (-> obj mtx-acc))
obj
)
;; failed to figure out what this is:
(let ((v0-5 0))
)

506
test/decompiler/reference/engine/data/art-h_REF.gc Normal file
View file

@ -0,0 +1,506 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type joint-anim
(deftype joint-anim (basic)
((name basic :offset-assert 4)
(number int16 :offset-assert 8)
(length int16 :offset-assert 10)
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type joint-anim
(defmethod inspect joint-anim ((obj joint-anim))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tnumber: ~D~%" (-> obj number))
(format #t "~Tlength: ~D~%" (-> obj length))
obj
)
;; definition of type joint-anim-matrix
(deftype joint-anim-matrix (joint-anim)
((matrix matrix :offset-assert 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition of type joint-anim-transformq
(deftype joint-anim-transformq (joint-anim)
((transformq transformq :offset-assert 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition of type joint-anim-drawable
(deftype joint-anim-drawable (joint-anim)
((data uint32 :inline :dynamic :offset-assert 12)
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type joint-anim-drawable
(defmethod inspect joint-anim-drawable ((obj joint-anim-drawable))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tnumber: ~D~%" (-> obj number))
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Tdata[0] @ #x~X~%" (-> obj data))
obj
)
;; definition of type joint-anim-compressed
(deftype joint-anim-compressed (joint-anim)
()
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type joint-anim-compressed
(defmethod inspect joint-anim-compressed ((obj joint-anim-compressed))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tnumber: ~D~%" (-> obj number))
(format #t "~Tlength: ~D~%" (-> obj length))
obj
)
;; definition of type joint-anim-frame
(deftype joint-anim-frame (structure)
((matrices matrix 2 :inline :offset-assert 0)
(data uint32 :dynamic :offset-assert 128)
)
:method-count-assert 9
:size-assert #x80
:flag-assert #x900000080
(:methods
(new (symbol type int) _type_ 0)
)
)
;; definition for method 3 of type joint-anim-frame
(defmethod inspect joint-anim-frame ((obj joint-anim-frame))
(format #t "[~8x] ~A~%" obj 'joint-anim-frame)
(format #t "~Tmatrices[2] @ #x~X~%" (-> obj matrices))
(format #t "~Tdata[0] @ #x~X~%" (-> obj data))
obj
)
;; definition for method 0 of type joint-anim-frame
;; INFO: Return type mismatch structure vs joint-anim-frame.
(defmethod
new
joint-anim-frame
((allocation symbol) (type-to-make type) (arg0 int))
(let ((v1-1 (max 0 (+ arg0 -2))))
(the-as
joint-anim-frame
(new-dynamic-structure
allocation
type-to-make
(the-as int (+ (-> type-to-make size) (the-as uint (* 48 v1-1))))
)
)
)
)
;; definition of type joint-anim-compressed-hdr
(deftype joint-anim-compressed-hdr (structure)
((control-bits uint32 14 :offset-assert 0)
(num-joints uint32 :offset-assert 56)
(matrix-bits uint32 :offset-assert 60)
)
:method-count-assert 9
:size-assert #x40
:flag-assert #x900000040
)
;; definition for method 3 of type joint-anim-compressed-hdr
(defmethod inspect joint-anim-compressed-hdr ((obj joint-anim-compressed-hdr))
(format #t "[~8x] ~A~%" obj 'joint-anim-compressed-hdr)
(format #t "~Tcontrol-bits[14] @ #x~X~%" (-> obj control-bits))
(format #t "~Tnum-joints: ~D~%" (-> obj num-joints))
(format #t "~Tmatrix-bits: ~D~%" (-> obj matrix-bits))
obj
)
;; definition of type joint-anim-compressed-fixed
(deftype joint-anim-compressed-fixed (structure)
((hdr joint-anim-compressed-hdr :inline :offset-assert 0)
(offset-64 uint32 :offset-assert 64)
(offset-32 uint32 :offset-assert 68)
(offset-16 uint32 :offset-assert 72)
(reserved uint32 :offset-assert 76)
(data vector 133 :inline :offset-assert 80)
)
:method-count-assert 9
:size-assert #x8a0
:flag-assert #x9000008a0
)
;; definition for method 3 of type joint-anim-compressed-fixed
(defmethod
inspect
joint-anim-compressed-fixed
((obj joint-anim-compressed-fixed))
(format #t "[~8x] ~A~%" obj 'joint-anim-compressed-fixed)
(format #t "~Thdr: #<joint-anim-compressed-hdr @ #x~X>~%" (-> obj hdr))
(format #t "~Toffset-64: ~D~%" (-> obj offset-64))
(format #t "~Toffset-32: ~D~%" (-> obj offset-32))
(format #t "~Toffset-16: ~D~%" (-> obj offset-16))
(format #t "~Treserved: ~D~%" (-> obj reserved))
(format #t "~Tdata[133] @ #x~X~%" (-> obj data))
obj
)
;; definition of type joint-anim-compressed-frame
(deftype joint-anim-compressed-frame (structure)
((offset-64 uint32 :offset-assert 0)
(offset-32 uint32 :offset-assert 4)
(offset-16 uint32 :offset-assert 8)
(reserved uint32 :offset-assert 12)
(data vector 133 :inline :offset-assert 16)
)
:method-count-assert 9
:size-assert #x860
:flag-assert #x900000860
)
;; definition for method 3 of type joint-anim-compressed-frame
(defmethod
inspect
joint-anim-compressed-frame
((obj joint-anim-compressed-frame))
(format #t "[~8x] ~A~%" obj 'joint-anim-compressed-frame)
(format #t "~Toffset-64: ~D~%" (-> obj offset-64))
(format #t "~Toffset-32: ~D~%" (-> obj offset-32))
(format #t "~Toffset-16: ~D~%" (-> obj offset-16))
(format #t "~Treserved: ~D~%" (-> obj reserved))
(format #t "~Tdata[133] @ #x~X~%" (-> obj data))
obj
)
;; definition of type joint-anim-compressed-control
(deftype joint-anim-compressed-control (structure)
((num-frames uint32 :offset-assert 0)
(fixed-qwc uint32 :offset-assert 4)
(frame-qwc uint32 :offset-assert 8)
(fixed joint-anim-compressed-fixed :offset-assert 12)
(data uint32 1 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x14
:flag-assert #x900000014
)
;; definition for method 3 of type joint-anim-compressed-control
(defmethod
inspect
joint-anim-compressed-control
((obj joint-anim-compressed-control))
(format #t "[~8x] ~A~%" obj 'joint-anim-compressed-control)
(format #t "~Tnum-frames: ~D~%" (-> obj num-frames))
(format #t "~Tfixed-qwc: ~D~%" (-> obj fixed-qwc))
(format #t "~Tframe-qwc: ~D~%" (-> obj frame-qwc))
(format #t "~Tfixed: #<joint-anim-compressed-fixed @ #x~X>~%" (-> obj fixed))
(format #t "~Tdata[1] @ #x~X~%" (-> obj data))
obj
)
;; definition of type art
(deftype art (basic)
((name basic :offset 8)
(length int32 :offset-assert 12)
(extra basic :offset-assert 16)
)
:method-count-assert 13
:size-assert #x14
:flag-assert #xd00000014
(:methods
(dummy-9 () none 9)
(dummy-10 () none 10)
(dummy-11 () none 11)
(dummy-12 () none 12)
)
)
;; definition for method 3 of type art
(defmethod inspect art ((obj art))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Textra: ~A~%" (-> obj extra))
obj
)
;; definition of type art-element
(deftype art-element (art)
((pad uint8 12 :offset-assert 20)
)
:method-count-assert 13
:size-assert #x20
:flag-assert #xd00000020
)
;; definition for method 3 of type art-element
(defmethod inspect art-element ((obj art-element))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Textra: ~A~%" (-> obj extra))
obj
)
;; definition of type art-mesh-anim
(deftype art-mesh-anim (art-element)
()
:method-count-assert 13
:size-assert #x20
:flag-assert #xd00000020
)
;; definition of type art-joint-anim
(deftype art-joint-anim (art-element)
((pad2 uint8 16 :offset-assert 32)
)
:method-count-assert 13
:size-assert #x30
:flag-assert #xd00000030
)
;; definition of type art-group
(deftype art-group (art)
((pad2 uint8 12 :offset-assert 20)
)
:method-count-assert 15
:size-assert #x20
:flag-assert #xf00000020
(:methods
(dummy-13 () none 13)
(dummy-14 () none 14)
)
)
;; definition of type art-mesh-geo
(deftype art-mesh-geo (art-element)
()
:method-count-assert 13
:size-assert #x20
:flag-assert #xd00000020
)
;; definition of type art-joint-geo
(deftype art-joint-geo (art-element)
()
:method-count-assert 13
:size-assert #x20
:flag-assert #xd00000020
)
;; definition of type skeleton-group
(deftype skeleton-group (basic)
((art-group-name basic :offset-assert 4)
(jgeo int32 :offset-assert 8)
(janim int32 :offset-assert 12)
(bounds vector :inline :offset-assert 16)
(radius float :offset 28)
(mgeo uint16 4 :offset-assert 32)
(max-lod int32 :offset-assert 40)
(lod-dist float 4 :offset-assert 44)
(longest-edge float :offset-assert 60)
(texture-level int8 :offset-assert 64)
(version int8 :offset-assert 65)
(shadow int8 :offset-assert 66)
(sort int8 :offset-assert 67)
(_pad uint8 4 :offset-assert 68)
)
:method-count-assert 9
:size-assert #x48
:flag-assert #x900000048
)
;; definition for method 3 of type skeleton-group
(defmethod inspect skeleton-group ((obj skeleton-group))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tart-group-name: ~A~%" (-> obj art-group-name))
(format #t "~Tjgeo: ~D~%" (-> obj jgeo))
(format #t "~Tjanim: ~D~%" (-> obj janim))
(format #t "~Tbounds: ~`vector`P~%" (-> obj bounds))
(format #t "~Tradius: (meters ~m)~%" (-> obj bounds w))
(format #t "~Tmgeo[4] @ #x~X~%" (-> obj mgeo))
(format #t "~Tmax-lod: ~D~%" (-> obj max-lod))
(format #t "~Tlod-dist[4] @ #x~X~%" (-> obj lod-dist))
(format #t "~Tlongest-edge: (meters ~m)~%" (-> obj longest-edge))
(format #t "~Ttexture-level: ~D~%" (-> obj texture-level))
(format #t "~Tversion: ~D~%" (-> obj version))
(format #t "~Tshadow: ~D~%" (-> obj shadow))
(format #t "~Tsort: ~D~%" (-> obj sort))
obj
)
;; definition of type lod-group
(deftype lod-group (structure)
((geo basic :offset-assert 0)
(dist float :offset-assert 4)
)
:pack-me
:method-count-assert 9
:size-assert #x8
:flag-assert #x900000008
)
;; definition for method 3 of type lod-group
(defmethod inspect lod-group ((obj lod-group))
(format #t "[~8x] ~A~%" obj 'lod-group)
(format #t "~Tgeo: ~A~%" (-> obj geo))
(format #t "~Tdist: (meters ~m)~%" (-> obj dist))
obj
)
;; definition of type lod-set
(deftype lod-set (structure)
((lod lod-group 4 :inline :offset-assert 0)
(max-lod int8 :offset-assert 32)
)
:pack-me
:method-count-assert 10
:size-assert #x21
:flag-assert #xa00000021
(:methods
(dummy-9 () none 9)
)
)
;; definition for method 3 of type lod-set
(defmethod inspect lod-set ((obj lod-set))
(format #t "[~8x] ~A~%" obj 'lod-set)
(format #t "~Tlod[4] @ #x~X~%" (-> obj lod))
(format #t "~Tmax-lod: ~D~%" (-> obj max-lod))
obj
)
;; definition of type draw-control
(deftype draw-control (basic)
((status uint8 :offset-assert 4)
(matrix-type uint8 :offset-assert 5)
(data-format uint8 :offset-assert 6)
(global-effect uint8 :offset-assert 7)
(art-group art-group :offset-assert 8)
(jgeo art-joint-geo :offset-assert 12)
(mgeo art-mesh-geo :offset-assert 16)
(dma-add-func function :offset-assert 20)
(skeleton skeleton-group :offset-assert 24)
(lod-set lod-set :inline :offset-assert 28)
(lod lod-group 4 :inline :offset 28)
(max-lod int8 :offset 60)
(force-lod int8 :offset-assert 61)
(cur-lod int8 :offset-assert 62)
(desired-lod int8 :offset-assert 63)
(ripple basic :offset-assert 64)
(longest-edge float :offset-assert 68)
(longest-edge? uint32 :offset 68)
(light-index uint8 :offset-assert 72)
(dummy uint8 2 :offset-assert 73)
(death-draw-overlap uint8 :offset-assert 75)
(death-timer uint8 :offset-assert 76)
(death-timer-org uint8 :offset-assert 77)
(death-vertex-skip uint16 :offset-assert 78)
(death-effect uint32 :offset-assert 80)
(sink-group basic :offset-assert 84)
(process process :offset-assert 88)
(shadow basic :offset-assert 92)
(shadow-ctrl basic :offset-assert 96)
(origin vector :inline :offset-assert 112)
(bounds vector :inline :offset-assert 128)
(radius float :offset 140)
(color-mult rgbaf :inline :offset-assert 144)
(color-emissive rgbaf :inline :offset-assert 160)
(secondary-interp float :offset-assert 176)
(current-secondary-interp float :offset-assert 180)
(shadow-mask uint8 :offset-assert 184)
(level-index uint8 :offset-assert 185)
(origin-joint-index uint8 :offset-assert 186)
(shadow-joint-index uint8 :offset-assert 187)
)
:method-count-assert 12
:size-assert #xbc
:flag-assert #xc000000bc
(:methods
(dummy-9 (_type_) (pointer int8) 9)
(dummy-10 () none 10)
(dummy-11 () none 11)
)
)
;; definition for method 3 of type draw-control
(defmethod inspect draw-control ((obj draw-control))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tstatus: ~D~%" (-> obj status))
(format #t "~Tmatrix-type: ~D~%" (-> obj matrix-type))
(format #t "~Tdata-format: ~D~%" (-> obj data-format))
(format #t "~Tglobal-effect: ~D~%" (-> obj global-effect))
(format #t "~Tart-group: ~A~%" (-> obj art-group))
(format #t "~Tjgeo: ~A~%" (-> obj jgeo))
(format #t "~Tmgeo: ~A~%" (-> obj mgeo))
(format #t "~Tdma-add-func: ~A~%" (-> obj dma-add-func))
(format #t "~Tskeleton: ~A~%" (-> obj skeleton))
(format #t "~Tlod-set: #<lod-set @ #x~X>~%" (-> obj lod-set))
(format #t "~Tlod[4] @ #x~X~%" (-> obj lod-set))
(format #t "~Tmax-lod: ~D~%" (-> obj lod-set max-lod))
(format #t "~Tforce-lod: ~D~%" (-> obj force-lod))
(format #t "~Tcur-lod: ~D~%" (-> obj cur-lod))
(format #t "~Tdesired-lod: ~D~%" (-> obj desired-lod))
(format #t "~Tripple: ~A~%" (-> obj ripple))
(format #t "~Tlongest-edge: (meters ~m)~%" (-> obj longest-edge))
(format #t "~Tlongest-edge?: ~D~%" (-> obj longest-edge))
(format #t "~Tlight-index: ~D~%" (-> obj light-index))
(format #t "~Tdummy[2] @ #x~X~%" (-> obj dummy))
(format #t "~Tdeath-draw-overlap: ~D~%" (-> obj death-draw-overlap))
(format #t "~Tdeath-timer: ~D~%" (-> obj death-timer))
(format #t "~Tdeath-timer-org: ~D~%" (-> obj death-timer-org))
(format #t "~Tdeath-vertex-skip: ~D~%" (-> obj death-vertex-skip))
(format #t "~Tdeath-effect: ~D~%" (-> obj death-effect))
(format #t "~Tsink-group: ~A~%" (-> obj sink-group))
(format #t "~Tprocess: ~A~%" (-> obj process))
(format #t "~Tshadow: ~A~%" (-> obj shadow))
(format #t "~Tshadow-ctrl: ~A~%" (-> obj shadow-ctrl))
(format #t "~Torigin: ~`vector`P~%" (-> obj origin))
(format #t "~Tbounds: ~`vector`P~%" (-> obj bounds))
(format #t "~Tradius: (meters ~m)~%" (-> obj bounds w))
(format #t "~Tcolor-mult: #<rgbaf @ #x~X>~%" (-> obj color-mult))
(format #t "~Tcolor-emissive: #<rgbaf @ #x~X>~%" (-> obj color-emissive))
(format #t "~Tsecondary-interp: ~f~%" (-> obj secondary-interp))
(format
#t
"~Tcurrent-secondary-interp: ~f~%"
(-> obj current-secondary-interp)
)
(format #t "~Tshadow-mask: ~D~%" (-> obj shadow-mask))
(format #t "~Tlevel-index: ~D~%" (-> obj level-index))
(format #t "~Torigin-joint-index: ~D~%" (-> obj origin-joint-index))
(format #t "~Tshadow-joint-index: ~D~%" (-> obj shadow-joint-index))
obj
)
;; definition for method 9 of type draw-control
(defmethod dummy-9 draw-control ((obj draw-control))
(&-> (-> obj skeleton) texture-level)
)
;; failed to figure out what this is:
(let ((v0-21 0))
)

26
test/decompiler/reference/engine/engine/engine_REF.gc Normal file
View file

@ -0,0 +1,26 @@
;;-*-Lisp-*-
(in-package goal)
;; definition for symbol *background-draw-engine*, type engine
(define *background-draw-engine* (new 'global 'engine 'draw 10))
;; definition for symbol *matrix-engine*, type (array handle)
(define
*matrix-engine*
(the-as (array handle) (new 'global 'boxed-array handle 1024))
)
;; failed to figure out what this is:
(set! (-> *matrix-engine* length) 0)
;; definition for symbol *camera-engine*, type engine
(define *camera-engine* (new 'global 'engine 'camera-eng 128))
;; failed to figure out what this is:
(if *debug-segment*
(set! *debug-engine* (new 'debug 'engine 'debug 512))
)

303
test/decompiler/reference/engine/game/game-info-h_REF.gc Normal file
View file

@ -0,0 +1,303 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type game-bank
(deftype game-bank (basic)
((life-max-default float :offset-assert 4)
(life-start-default float :offset-assert 8)
(life-single-inc float :offset-assert 12)
(money-task-inc float :offset-assert 16)
(money-oracle-inc float :offset-assert 20)
)
:method-count-assert 9
:size-assert #x18
:flag-assert #x900000018
)
;; definition for method 3 of type game-bank
(defmethod inspect game-bank ((obj game-bank))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tlife-max-default: ~f~%" (-> obj life-max-default))
(format #t "~Tlife-start-default: ~f~%" (-> obj life-start-default))
(format #t "~Tlife-single-inc: ~f~%" (-> obj life-single-inc))
(format #t "~Tmoney-task-inc: ~f~%" (-> obj money-task-inc))
(format #t "~Tmoney-oracle-inc: ~f~%" (-> obj money-oracle-inc))
obj
)
;; definition for symbol *GAME-bank*, type game-bank
(define
*GAME-bank*
(new 'static 'game-bank
:life-max-default 99.0
:life-start-default 5.0
:life-single-inc 1.0
:money-task-inc 90.0
:money-oracle-inc 120.0
)
)
;; definition of type actor-id
(deftype actor-id (uint32)
()
:method-count-assert 9
:size-assert #x4
:flag-assert #x900000004
)
;; definition of type level-buffer-state
(deftype level-buffer-state (structure)
((name basic :offset-assert 0)
(display? basic :offset-assert 4)
(force-vis? basic :offset-assert 8)
(force-inside? basic :offset-assert 12)
)
:pack-me
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type level-buffer-state
(defmethod inspect level-buffer-state ((obj level-buffer-state))
(format #t "[~8x] ~A~%" obj 'level-buffer-state)
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tdisplay?: ~A~%" (-> obj display?))
(format #t "~Tforce-vis?: ~A~%" (-> obj force-vis?))
(format #t "~Tforce-inside?: ~A~%" (-> obj force-inside?))
obj
)
;; definition of type load-state
(deftype load-state (basic)
((want level-buffer-state 2 :inline :offset-assert 4)
(vis-nick basic :offset-assert 36)
(command-list pair :offset-assert 40)
(object-name basic 256 :offset-assert 44)
(object-status basic 256 :offset-assert 1068)
)
:method-count-assert 21
:size-assert #x82c
:flag-assert #x150000082c
(:methods
(new (symbol type) _type_ 0)
(reset! (_type_) _type_ 9)
(dummy-10 () none 10)
(dummy-11 () none 11)
(dummy-12 () none 12)
(dummy-13 () none 13)
(dummy-14 () none 14)
(dummy-15 () none 15)
(dummy-16 () none 16)
(dummy-17 () none 17)
(dummy-18 () none 18)
(dummy-19 () none 19)
(dummy-20 () none 20)
)
)
;; definition for method 3 of type load-state
(defmethod inspect load-state ((obj load-state))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Twant[2] @ #x~X~%" (-> obj want))
(format #t "~Tvis-nick: ~A~%" (-> obj vis-nick))
(format #t "~Tcommand-list: ~A~%" (-> obj command-list))
(format #t "~Tobject-name[256] @ #x~X~%" (-> obj object-name))
(format #t "~Tobject-status[256] @ #x~X~%" (-> obj object-status))
obj
)
;; definition for method 0 of type load-state
(defmethod new load-state ((allocation symbol) (type-to-make type))
(reset!
(object-new allocation type-to-make (the-as int (-> type-to-make size)))
)
)
;; definition of type continue-point
(deftype continue-point (basic)
((name basic :offset-assert 4)
(level basic :offset-assert 8)
(flags uint32 :offset-assert 12)
(trans vector :inline :offset-assert 16)
(quat vector :inline :offset-assert 32)
(camera-trans vector :inline :offset-assert 48)
(camera-rot float 9 :offset-assert 64)
(load-commands pair :offset-assert 100)
(vis-nick basic :offset-assert 104)
(lev0 basic :offset-assert 108)
(disp0 basic :offset-assert 112)
(lev1 basic :offset-assert 116)
(disp1 basic :offset-assert 120)
)
:method-count-assert 10
:size-assert #x7c
:flag-assert #xa0000007c
(:methods
(dummy-9 () none 9)
)
)
;; definition for method 3 of type continue-point
(defmethod inspect continue-point ((obj continue-point))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tlevel: ~A~%" (-> obj level))
(format #t "~Tflags: ~D~%" (-> obj flags))
(format #t "~Ttrans: ~`vector`P~%" (-> obj trans))
(format #t "~Tquat: ~`vector`P~%" (-> obj quat))
(format #t "~Tcamera-trans: ~`vector`P~%" (-> obj camera-trans))
(format #t "~Tcamera-rot[9] @ #x~X~%" (-> obj camera-rot))
(format #t "~Tload-commands: ~A~%" (-> obj load-commands))
(format #t "~Tvis-nick: ~A~%" (-> obj vis-nick))
(format #t "~Tlev0: ~A~%" (-> obj lev0))
(format #t "~Tdisp0: ~A~%" (-> obj disp0))
(format #t "~Tlev1: ~A~%" (-> obj lev1))
(format #t "~Tdisp1: ~A~%" (-> obj disp1))
obj
)
;; definition of type game-info
(deftype game-info (basic)
((mode basic :offset-assert 4)
(save-name basic :offset-assert 8)
(life float :offset-assert 12)
(life-max float :offset-assert 16)
(money float :offset-assert 20)
(money-total float :offset-assert 24)
(money-per-level uint8 32 :offset-assert 28)
(deaths-per-level uint8 32 :offset-assert 60)
(buzzer-total float :offset-assert 92)
(fuel float :offset-assert 96)
(perm-list basic :offset-assert 100)
(task-perm-list basic :offset-assert 104)
(current-continue basic :offset-assert 108)
(text-ids-seen basic :offset-assert 112)
(level-opened uint8 32 :offset-assert 116)
(hint-control basic :offset-assert 148)
(task-hint-control basic :offset-assert 152)
(total-deaths int32 :offset-assert 156)
(continue-deaths int32 :offset-assert 160)
(fuel-cell-deaths int32 :offset-assert 164)
(game-start-time uint64 :offset-assert 168)
(continue-time uint64 :offset-assert 176)
(death-time uint64 :offset-assert 184)
(hit-time uint64 :offset-assert 192)
(fuel-cell-pickup-time uint64 :offset-assert 200)
(fuel-cell-time basic :offset-assert 208)
(enter-level-time basic :offset-assert 212)
(in-level-time basic :offset-assert 216)
(blackout-time uint64 :offset-assert 224)
(letterbox-time uint64 :offset-assert 232)
(hint-play-time uint64 :offset-assert 240)
(display-text-time uint64 :offset-assert 248)
(display-text-handle uint64 :offset-assert 256)
(death-movie-tick int32 :offset-assert 264)
(want-auto-save basic :offset-assert 268)
(auto-save-proc uint64 :offset-assert 272)
(auto-save-status uint32 :offset-assert 280)
(auto-save-card int32 :offset-assert 284)
(auto-save-which int32 :offset-assert 288)
(pov-camera-handle uint64 :offset-assert 296)
(other-camera-handle uint64 :offset-assert 304)
(death-pos basic :offset-assert 312)
(dummy basic :offset-assert 316)
(auto-save-count int32 :offset-assert 320)
)
:method-count-assert 29
:size-assert #x144
:flag-assert #x1d00000144
(:methods
(dummy-9 () none 9)
(dummy-10 () none 10)
(dummy-11 () none 11)
(dummy-12 () none 12)
(dummy-13 () none 13)
(dummy-14 () none 14)
(dummy-15 () none 15)
(dummy-16 () none 16)
(dummy-17 () none 17)
(dummy-18 () none 18)
(dummy-19 () none 19)
(dummy-20 () none 20)
(dummy-21 () none 21)
(dummy-22 () none 22)
(dummy-23 () none 23)
(dummy-24 () none 24)
(dummy-25 () none 25)
(dummy-26 () none 26)
(dummy-27 () none 27)
(dummy-28 () none 28)
)
)
;; definition for method 3 of type game-info
(defmethod inspect game-info ((obj game-info))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tmode: ~A~%" (-> obj mode))
(format #t "~Tsave-name: ~A~%" (-> obj save-name))
(format #t "~Tlife: ~f~%" (-> obj life))
(format #t "~Tlife-max: ~f~%" (-> obj life-max))
(format #t "~Tmoney: ~f~%" (-> obj money))
(format #t "~Tmoney-total: ~f~%" (-> obj money-total))
(format #t "~Tmoney-per-level[32] @ #x~X~%" (-> obj money-per-level))
(format #t "~Tdeaths-per-level[32] @ #x~X~%" (-> obj deaths-per-level))
(format #t "~Tbuzzer-total: ~f~%" (-> obj buzzer-total))
(format #t "~Tfuel: ~f~%" (-> obj fuel))
(format #t "~Tperm-list: ~A~%" (-> obj perm-list))
(format #t "~Ttask-perm-list: ~A~%" (-> obj task-perm-list))
(format #t "~Tcurrent-continue: ~A~%" (-> obj current-continue))
(format #t "~Ttext-ids-seen: ~A~%" (-> obj text-ids-seen))
(format #t "~Tlevel-opened[32] @ #x~X~%" (-> obj level-opened))
(format #t "~Thint-control: ~A~%" (-> obj hint-control))
(format #t "~Ttask-hint-control: ~A~%" (-> obj task-hint-control))
(format #t "~Ttotal-deaths: ~D~%" (-> obj total-deaths))
(format #t "~Tcontinue-deaths: ~D~%" (-> obj continue-deaths))
(format #t "~Tfuel-cell-deaths: ~D~%" (-> obj fuel-cell-deaths))
(format #t "~Tgame-start-time: ~D~%" (-> obj game-start-time))
(format #t "~Tcontinue-time: ~D~%" (-> obj continue-time))
(format #t "~Tdeath-time: ~D~%" (-> obj death-time))
(format #t "~Thit-time: ~D~%" (-> obj hit-time))
(format #t "~Tfuel-cell-pickup-time: ~D~%" (-> obj fuel-cell-pickup-time))
(format #t "~Tfuel-cell-time: ~A~%" (-> obj fuel-cell-time))
(format #t "~Tenter-level-time: ~A~%" (-> obj enter-level-time))
(format #t "~Tin-level-time: ~A~%" (-> obj in-level-time))
(format #t "~Tblackout-time: ~D~%" (-> obj blackout-time))
(format #t "~Tletterbox-time: ~D~%" (-> obj letterbox-time))
(format #t "~Thint-play-time: ~D~%" (-> obj hint-play-time))
(format #t "~Tdisplay-text-time: ~D~%" (-> obj display-text-time))
(format #t "~Tdisplay-text-handle: ~D~%" (-> obj display-text-handle))
(format #t "~Tdeath-movie-tick: ~D~%" (-> obj death-movie-tick))
(format #t "~Twant-auto-save: ~A~%" (-> obj want-auto-save))
(format #t "~Tauto-save-proc: ~D~%" (-> obj auto-save-proc))
(format #t "~Tauto-save-status: ~D~%" (-> obj auto-save-status))
(format #t "~Tauto-save-card: ~D~%" (-> obj auto-save-card))
(format #t "~Tauto-save-which: ~D~%" (-> obj auto-save-which))
(format #t "~Tpov-camera-handle: ~D~%" (-> obj pov-camera-handle))
(format #t "~Tother-camera-handle: ~D~%" (-> obj other-camera-handle))
(format #t "~Tdeath-pos: ~A~%" (-> obj death-pos))
(format #t "~Tdummy: ~A~%" (-> obj dummy))
(format #t "~Tauto-save-count: ~D~%" (-> obj auto-save-count))
obj
)
;; failed to figure out what this is:
(set! gp-0 (when (or (not *game-info*) (zero? *game-info*))
(set!
gp-0
(new 'static 'game-info :mode 'debug :current-continue #f)
)
(set! (-> gp-0 fuel-cell-time) (new 'global 'boxed-array uint64 116))
(set!
(-> gp-0 enter-level-time)
(new 'global 'boxed-array uint64 32)
)
(set! (-> gp-0 in-level-time) (new 'global 'boxed-array uint64 32))
(set! *game-info* gp-0)
gp-0
)
)

88
test/decompiler/reference/engine/gfx/generic/generic-vu1-h_REF.gc Normal file
View file

@ -0,0 +1,88 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type pris-mtx
(deftype pris-mtx (structure)
((data float 32 :offset 0)
(vector vector 8 :inline :offset 0)
(t-mtx matrix :inline :offset 0)
(n-mtx matrix3 :inline :offset 64)
(scale vector :inline :offset 112)
)
:method-count-assert 9
:size-assert #x80
:flag-assert #x900000080
)
;; definition for method 3 of type pris-mtx
(defmethod inspect pris-mtx ((obj pris-mtx))
(format #t "[~8x] ~A~%" obj 'pris-mtx)
(format #t "~Tdata[32] @ #x~X~%" (-> obj data))
(format #t "~Tvector[8] @ #x~X~%" (-> obj data))
(format #t "~Tt-mtx: #<matrix @ #x~X>~%" (-> obj data))
(format #t "~Tn-mtx: #<matrix3 @ #x~X>~%" (&-> obj data 16))
(format #t "~Tscale: #<vector @ #x~X>~%" (&-> obj data 28))
obj
)
;; definition of type generic-pris-mtx-save
(deftype generic-pris-mtx-save (structure)
((loc-mtx pris-mtx :inline :offset-assert 0)
(par-mtx pris-mtx :inline :offset-assert 128)
(dif-mtx pris-mtx :inline :offset-assert 256)
)
:method-count-assert 9
:size-assert #x180
:flag-assert #x900000180
)
;; definition for method 3 of type generic-pris-mtx-save
(defmethod inspect generic-pris-mtx-save ((obj generic-pris-mtx-save))
(format #t "[~8x] ~A~%" obj 'generic-pris-mtx-save)
(format #t "~Tloc-mtx: #<pris-mtx @ #x~X>~%" (-> obj loc-mtx))
(format #t "~Tpar-mtx: #<pris-mtx @ #x~X>~%" (-> obj par-mtx))
(format #t "~Tdif-mtx: #<pris-mtx @ #x~X>~%" (-> obj dif-mtx))
obj
)
;; definition of type generic-constants
(deftype generic-constants (structure)
((fog vector :inline :offset-assert 0)
(adgif qword :inline :offset-assert 16)
(giftag qword :inline :offset-assert 32)
(hvdf-offset vector :inline :offset-assert 48)
(hmge-scale vector :inline :offset-assert 64)
(invh-scale vector :inline :offset-assert 80)
(guard vector :inline :offset-assert 96)
(adnop qword :inline :offset-assert 112)
(flush qword :inline :offset-assert 128)
(stores qword :inline :offset-assert 144)
)
:method-count-assert 9
:size-assert #xa0
:flag-assert #x9000000a0
)
;; definition for method 3 of type generic-constants
(defmethod inspect generic-constants ((obj generic-constants))
(format #t "[~8x] ~A~%" obj 'generic-constants)
(format #t "~Tfog: #<vector @ #x~X>~%" (-> obj fog))
(format #t "~Tadgif: #<qword @ #x~X>~%" (-> obj adgif))
(format #t "~Tgiftag: #<qword @ #x~X>~%" (-> obj giftag))
(format #t "~Thvdf-offset: #<vector @ #x~X>~%" (-> obj hvdf-offset))
(format #t "~Thmge-scale: #<vector @ #x~X>~%" (-> obj hmge-scale))
(format #t "~Tinvh-scale: #<vector @ #x~X>~%" (-> obj invh-scale))
(format #t "~Tguard: #<vector @ #x~X>~%" (-> obj guard))
(format #t "~Tadnop: #<qword @ #x~X>~%" (-> obj adnop))
(format #t "~Tflush: #<qword @ #x~X>~%" (-> obj flush))
(format #t "~Tstores: #<qword @ #x~X>~%" (-> obj stores))
obj
)
;; failed to figure out what this is:
(let ((v0-3 0))
)

193
test/decompiler/reference/engine/gfx/generic/generic-work-h_REF.gc Normal file
View file

@ -0,0 +1,193 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type generic-input-buffer
(deftype generic-input-buffer (structure)
((merc generic-merc-work :inline :offset 0)
(tie generic-tie-work :inline :offset 0)
(data uint128 472 :offset 0)
)
:method-count-assert 9
:size-assert #x1d80
:flag-assert #x900001d80
)
;; definition for method 3 of type generic-input-buffer
(defmethod inspect generic-input-buffer ((obj generic-input-buffer))
(format #t "[~8x] ~A~%" obj 'generic-input-buffer)
(format #t "~Tdata[472] @ #x~X~%" (-> obj merc))
(format #t "~Tmerc: #<generic-merc-work @ #x~X>~%" (-> obj merc))
(format #t "~Ttie: #<generic-tie-work @ #x~X>~%" (-> obj merc))
obj
)
;; definition of type generic-debug
(deftype generic-debug (structure)
((locks uint32 4 :offset-assert 0)
(timer uint32 32 :offset-assert 16)
(count uint32 32 :offset-assert 144)
(vps uint32 32 :offset-assert 272)
(buffer int32 :offset-assert 400)
(start-addr int32 :offset-assert 404)
(lock int32 :offset-assert 408)
)
:method-count-assert 9
:size-assert #x19c
:flag-assert #x90000019c
)
;; definition for method 3 of type generic-debug
(defmethod inspect generic-debug ((obj generic-debug))
(format #t "[~8x] ~A~%" obj 'generic-debug)
(format #t "~Tlocks[4] @ #x~X~%" (-> obj locks))
(format #t "~Ttimer[32] @ #x~X~%" (-> obj timer))
(format #t "~Tcount[32] @ #x~X~%" (-> obj count))
(format #t "~Tvps[32] @ #x~X~%" (-> obj vps))
(format #t "~Tbuffer: ~D~%" (-> obj buffer))
(format #t "~Tstart-addr: ~D~%" (-> obj start-addr))
(format #t "~Tlock: ~D~%" (-> obj lock))
obj
)
;; definition of type generic-vu1-header
(deftype generic-vu1-header (structure)
((matrix matrix :inline :offset-assert 0)
(strgif generic-gif-tag :inline :offset-assert 64)
(adnop1 ad-cmd :inline :offset-assert 80)
(adnop2 ad-cmd :inline :offset-assert 96)
(adcmds ad-cmd 2 :inline :offset 80)
(dps uint16 :offset 92)
(kickoff uint16 :offset 108)
(strips uint16 :offset 76)
)
:method-count-assert 9
:size-assert #x70
:flag-assert #x900000070
)
;; definition for method 3 of type generic-vu1-header
(defmethod inspect generic-vu1-header ((obj generic-vu1-header))
(format #t "[~8x] ~A~%" obj 'generic-vu1-header)
(format #t "~Tmatrix: #<matrix @ #x~X>~%" (-> obj matrix))
(format #t "~Tstrgif: #<generic-gif-tag @ #x~X>~%" (-> obj strgif))
(format #t "~Tadcmds[2] @ #x~X~%" (-> obj adnop1))
(format #t "~Tadnop1: #<ad-cmd @ #x~X>~%" (-> obj adnop1))
(format #t "~Tadnop2: #<ad-cmd @ #x~X>~%" (-> obj adnop2))
(format #t "~Tdps: ~D~%" (-> obj dps))
(format #t "~Tkickoff: ~D~%" (-> obj kickoff))
(format #t "~Tstrips: ~D~%" (-> obj strgif qword hword 6))
obj
)
;; definition of type generic-vu1-texbuf
(deftype generic-vu1-texbuf (structure)
((header generic-vu1-header :inline :offset-assert 0)
(shader uint32 :dynamic :offset-assert 112)
)
:method-count-assert 9
:size-assert #x70
:flag-assert #x900000070
)
;; definition for method 3 of type generic-vu1-texbuf
(defmethod inspect generic-vu1-texbuf ((obj generic-vu1-texbuf))
(format #t "[~8x] ~A~%" obj 'generic-vu1-texbuf)
(format #t "~Theader: #<generic-vu1-header @ #x~X>~%" (-> obj header))
(format #t "~Tshader[0] @ #x~X~%" (-> obj shader))
obj
)
;; definition of type generic-texbuf
(deftype generic-texbuf (structure)
((tag dma-packet :inline :offset-assert 0)
(header generic-vu1-header :inline :offset-assert 16)
(shader uint32 :dynamic :offset-assert 128)
)
:method-count-assert 9
:size-assert #x80
:flag-assert #x900000080
)
;; definition for method 3 of type generic-texbuf
(defmethod inspect generic-texbuf ((obj generic-texbuf))
(format #t "[~8x] ~A~%" obj 'generic-texbuf)
(format #t "~Ttag: #<dma-packet @ #x~X>~%" (-> obj tag))
(format #t "~Theader: #<generic-vu1-header @ #x~X>~%" (-> obj header))
(format #t "~Tshader[0] @ #x~X~%" (-> obj shader))
obj
)
;; definition of type generic-effect-work
(deftype generic-effect-work (structure)
((consts generic-consts :inline :offset-assert 0)
(storage generic-storage :inline :offset-assert 432)
(storage2 generic-storage :inline :offset-assert 688)
(lights vu-lights :inline :offset-assert 944)
)
:method-count-assert 9
:size-assert #x420
:flag-assert #x900000420
)
;; definition for method 3 of type generic-effect-work
(defmethod inspect generic-effect-work ((obj generic-effect-work))
(format #t "[~8x] ~A~%" obj 'generic-effect-work)
(format #t "~Tconsts: #<generic-consts @ #x~X>~%" (-> obj consts))
(format #t "~Tstorage: #<generic-storage @ #x~X>~%" (-> obj storage))
(format #t "~Tstorage2: #<generic-storage @ #x~X>~%" (-> obj storage2))
(format #t "~Tlights: #<vu-lights @ #x~X>~%" (-> obj lights))
obj
)
;; definition of type generic-effect-buffer
(deftype generic-effect-buffer (structure)
((outbuf-0 uint8 3552 :offset-assert 0)
(work generic-effect-work :inline :offset-assert 3552)
(outbuf-1 uint8 3552 :offset-assert 4608)
)
:method-count-assert 9
:size-assert #x1fe0
:flag-assert #x900001fe0
)
;; definition for method 3 of type generic-effect-buffer
(defmethod inspect generic-effect-buffer ((obj generic-effect-buffer))
(format #t "[~8x] ~A~%" obj 'generic-effect-buffer)
(format #t "~Toutbuf-0[3552] @ #x~X~%" (-> obj outbuf-0))
(format #t "~Twork: #<generic-effect-work @ #x~X>~%" (-> obj work))
(format #t "~Toutbuf-1[3552] @ #x~X~%" (-> obj outbuf-1))
obj
)
;; definition of type generic-work
(deftype generic-work (structure)
((saves generic-saves :inline :offset-assert 0)
(storage generic-storage :inline :offset-assert 368)
(in-buf generic-input-buffer :inline :offset-assert 624)
(fx-buf generic-effect-buffer :inline :offset-assert 8176)
)
:method-count-assert 9
:size-assert #x3fd0
:flag-assert #x900003fd0
)
;; definition for method 3 of type generic-work
(defmethod inspect generic-work ((obj generic-work))
(format #t "[~8x] ~A~%" obj 'generic-work)
(format #t "~Tsaves: #<generic-saves @ #x~X>~%" (-> obj saves))
(format #t "~Tstorage: #<generic-storage @ #x~X>~%" (-> obj storage))
(format #t "~Tin-buf: #<generic-input-buffer @ #x~X>~%" (-> obj in-buf))
(format #t "~Tfx-buf: #<generic-effect-buffer @ #x~X>~%" (-> obj fx-buf))
obj
)
;; definition for symbol *generic-debug*, type generic-debug
(define *generic-debug* (new 'global 'generic-debug))
;; failed to figure out what this is:
(let ((v0-9 0))
)

69
test/decompiler/reference/engine/gfx/hw/display_REF.gc
View file

@ -53,7 +53,7 @@
(set! (-> env smode2) (new 'static 'gs-smode2 :int #x1 :ffmd #x1))
(set!
(-> env dspfb)
(new 'static 'gs-display-fb :psm psm :fbw (sar width 6) :fbp fbp)
(new 'static 'gs-display-fb :psm psm :fbw (/ width 64) :fbp fbp)
)
(set!
(-> env display)
@ -61,7 +61,7 @@
:dw #x9ff
:dy (+ dy 50)
:dx (+ (* dx (/ 2560 width)) 652)
:dh (+ (shl height 1) -1)
:dh (+ (* height 2) -1)
:magh (+ (/ (+ width 2559) width) -1)
)
)
@ -83,7 +83,7 @@
(set! (-> env frame1addr) (gs-reg64 frame-1))
(set!
(-> env frame1)
(new 'static 'gs-frame :fbw (sar width 6) :psm (logand psm 15) :fbp fbp)
(new 'static 'gs-frame :fbw (/ width 64) :psm (logand psm 15) :fbp fbp)
)
(set! (-> env dtheaddr) (gs-reg64 dthe))
(cond
@ -121,7 +121,7 @@
(-> env xyoffset1)
(new 'static 'gs-xy-offset
:ofx #x7000
:ofy (shl (-> *video-parms* screen-miny) 4)
:ofy (* (-> *video-parms* screen-miny) 16)
)
)
(set! (-> env scissor1addr) (gs-reg64 scissor-1))
@ -141,8 +141,8 @@
(set!
(-> env xyoffset1)
(new 'static 'gs-xy-offset
:ofx (shl (- x (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scax1)) (the-as uint 1))) 1))) 4)
:ofy (+ (shl (- y (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scay1)) (the-as uint 1))) 1))) 4) (if (zero? arg3) 0 8))
:ofx (* (- x (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scax1)) (the-as uint 1))) 1))) 16)
:ofy (+ (* (- y (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scay1)) (the-as uint 1))) 1))) 16) (if (zero? arg3) 0 8))
)
)
env
@ -283,7 +283,7 @@
;; definition for method 11 of type profile-bar
(defmethod add-frame profile-bar ((obj profile-bar) (name symbol) (color rgba))
(if *debug-segment*
(when *debug-segment*
(let ((new-frame (-> obj data (-> obj profile-frame-count))))
(set! (-> obj profile-frame-count) (+ (-> obj profile-frame-count) 1))
(set! (-> new-frame name) name)
@ -341,7 +341,7 @@
)
(let ((block-idx 1)
(block-count (-> obj profile-frame-count))
(left (shl *profile-x* 4))
(left (* *profile-x* 16))
(end-time 0)
(worst-time-cache (new 'static 'array uint32 2 #x0 #x0))
)
@ -355,10 +355,7 @@
)
(set!
(-> direct-tag dma)
(new 'static 'dma-tag
:id (dma-tag-id cnt)
:qwc (+ (shl block-count 1) -1)
)
(new 'static 'dma-tag :id (dma-tag-id cnt) :qwc (+ (* block-count 2) -1))
)
(set! (-> direct-tag vif0) (new 'static 'vif-tag))
(set!
@ -366,7 +363,7 @@
(new 'static 'vif-tag
:cmd (vif-cmd direct)
:msk #x1
:imm (+ (shl block-count 1) -1)
:imm (+ (* block-count 2) -1)
)
)
(set! (-> t1-0 base) (&+ (the-as pointer direct-tag) 16))
@ -410,7 +407,7 @@
(-> (the-as (pointer gs-xyzf) t3-8) 2)
(new 'static 'gs-xyzf
:z #x3fffff
:y (shl (+ *profile-y* screen-y) 4)
:y (* (+ *profile-y* screen-y) 16)
:x left
)
)
@ -421,7 +418,7 @@
)
(set!
left
(shl
(*
(+
*profile-x*
(the-as
@ -432,7 +429,7 @@
)
)
)
4
16
)
)
)
@ -443,7 +440,7 @@
(-> (the-as (pointer gs-xyzf) t2-8) 0)
(new 'static 'gs-xyzf
:z #x3fffff
:y (shl (+ (+ *profile-y* screen-y) *profile-h*) 4)
:y (* (+ (+ *profile-y* screen-y) *profile-h*) 16)
:x left
)
)
@ -573,21 +570,21 @@
)
(set!
(-> (the-as (pointer gs-xyzf) gif-buf) 2)
(new 'static 'gs-xyzf :z #x3fffff :y (shl draw-y 4) :x (shl draw-x 4))
(new 'static 'gs-xyzf :z #x3fffff :y (* draw-y 16) :x (* draw-x 16))
)
(set!
(-> (the-as (pointer gs-xyzf) gif-buf) 3)
(new 'static 'gs-xyzf
:z #x3fffff
:y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4)
:x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4)
:y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16)
:x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16)
)
)
(set! (-> a2-4 base) (&+ gif-buf 32))
)
(let
((total-qwc
(sar (&+ (- -16 (the-as int (the-as pointer end-dma))) (-> buf base)) 4)
(/ (&+ (- -16 (the-as int (the-as pointer end-dma))) (-> buf base)) 16)
)
)
(cond
@ -676,7 +673,7 @@
)
(set!
(-> (the-as (pointer gs-xyzf) gif-buf) 2)
(new 'static 'gs-xyzf :y (shl draw-y 4) :x (shl draw-x 4))
(new 'static 'gs-xyzf :y (* draw-y 16) :x (* draw-x 16))
)
(set!
(-> (the-as (pointer gs-rgbaq) gif-buf) 3)
@ -685,8 +682,8 @@
(set!
(-> (the-as (pointer gs-xyzf) gif-buf) 4)
(new 'static 'gs-xyzf
:y (shl draw-y 4)
:x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4)
:y (* draw-y 16)
:x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16)
)
)
(set!
@ -696,8 +693,8 @@
(set!
(-> (the-as (pointer gs-xyzf) gif-buf) 6)
(new 'static 'gs-xyzf
:y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4)
:x (shl draw-x 4)
:y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16)
:x (* draw-x 16)
)
)
(set!
@ -707,14 +704,14 @@
(set!
(-> (the-as (pointer gs-xyzf) gif-buf) 8)
(new 'static 'gs-xyzf
:y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4)
:x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4)
:y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16)
:x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16)
)
)
(set! (-> (the-as (pointer uint64) gif-buf) 9) (the-as uint 0))
(set! (-> t0-2 base) (&+ gif-buf 80))
)
(let ((total-qwc (sar (&+ (- -16 (the-as int end-dma)) (-> buf base)) 4)))
(let ((total-qwc (/ (&+ (- -16 (the-as int end-dma)) (-> buf base)) 16)))
(cond
((nonzero? total-qwc)
(set!
@ -794,7 +791,7 @@
(defun
set-display-gs-state
((dma-buf dma-buffer) (fbp int) (scx int) (scy int) (fb-msk int) (psm int))
(let ((fbw (sar (+ scx 63) 6)))
(let ((fbw (/ (+ scx 63) 64)))
(let* ((v1-1 dma-buf)
(dma (the-as dma-packet (-> v1-1 base)))
)
@ -886,7 +883,7 @@
(off-x int)
(off-y int)
)
(let ((fbw (sar (+ width 63) 6)))
(let ((fbw (/ (+ width 63) 64)))
(let* ((v1-1 dma-buf)
(dma (the-as dma-packet (-> v1-1 base)))
)
@ -935,7 +932,7 @@
(set! (-> (the-as (pointer gs-reg64) gif-data) 1) (gs-reg64 scissor-1))
(set!
(-> (the-as (pointer gs-xy-offset) gif-data) 2)
(new 'static 'gs-xy-offset :ofx (shl off-x 4) :ofy (shl off-y 4))
(new 'static 'gs-xy-offset :ofx (* off-x 16) :ofy (* off-y 16))
)
(set! (-> (the-as (pointer gs-reg64) gif-data) 3) (gs-reg64 xyoffset-1))
(set!
@ -970,7 +967,7 @@
;; INFO: Return type mismatch display vs none.
(defun reset-display-gs-state ((disp display) (dma-buf dma-buffer) (oddeven int))
(let* ((onscreen (-> disp on-screen))
(hoff (shl oddeven 3))
(hoff (* oddeven 8))
(fbp (-> disp frames onscreen draw frame1 fbp))
)
(let* ((a3-1 dma-buf)
@ -1024,7 +1021,7 @@
(-> (the-as (pointer gs-xy-offset) gif-data) 2)
(new 'static 'gs-xy-offset
:ofx #x7000
:ofy (+ (shl (-> *video-parms* screen-miny) 4) hoff)
:ofy (+ (* (-> *video-parms* screen-miny) 16) hoff)
)
)
(set! (-> (the-as (pointer gs-reg64) gif-data) 3) (gs-reg64 xyoffset-1))
@ -1064,7 +1061,3 @@
;; failed to figure out what this is:
(allocate-dma-buffers *display*)

289
test/decompiler/reference/engine/gfx/merc/generic-merc-h_REF.gc Normal file
View file

@ -0,0 +1,289 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type merc-matrix
(deftype merc-matrix (structure)
((quad uint128 8 :offset-assert 0)
(vector vector 8 :inline :offset 0)
(tag uint64 :offset 0)
)
:method-count-assert 9
:size-assert #x80
:flag-assert #x900000080
)
;; definition for method 3 of type merc-matrix
(defmethod inspect merc-matrix ((obj merc-matrix))
(format #t "[~8x] ~A~%" obj 'merc-matrix)
(format #t "~Tquad[8] @ #x~X~%" (-> obj quad))
(format #t "~Tvector[8] @ #x~X~%" (-> obj quad))
(format #t "~Ttag: ~D~%" (-> obj tag))
obj
)
;; definition of type generic-merc-tag
(deftype generic-merc-tag (dma-packet)
((next-ptr uint32 :offset 12)
(size uint32 :offset 8)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type generic-merc-tag
;; Used lq/sq
(defmethod inspect generic-merc-tag ((obj generic-merc-tag))
(format #t "[~8x] ~A~%" obj 'generic-merc-tag)
(format #t "~Tdma: #x~X~%" (-> obj dma))
(format #t "~Tvif0: #x~X~%" (-> obj vif0))
(format #t "~Tvif1: #x~X~%" (-> obj vif1))
(format #t "~Tquad: ~D~%" (-> obj quad))
(format #t "~Tnext-ptr: ~D~%" (-> obj vif1))
(format #t "~Tsize: ~D~%" (-> obj vif0))
obj
)
;; definition of type generic-merc-ctrl
(deftype generic-merc-ctrl (structure)
((tag generic-merc-tag :inline :offset-assert 0)
(lights vu-lights :inline :offset-assert 16)
(header merc-ctrl-header :inline :offset-assert 128)
(effect merc-effect :inline :offset-assert 208)
)
:method-count-assert 9
:size-assert #xf0
:flag-assert #x9000000f0
)
;; definition for method 3 of type generic-merc-ctrl
(defmethod inspect generic-merc-ctrl ((obj generic-merc-ctrl))
(format #t "[~8x] ~A~%" obj 'generic-merc-ctrl)
(format #t "~Ttag: #<generic-merc-tag @ #x~X>~%" (-> obj tag))
(format #t "~Tlights: #<vu-lights @ #x~X>~%" (-> obj lights))
(format #t "~Theader: #<merc-ctrl-header @ #x~X>~%" (-> obj header))
(format #t "~Teffect: #<merc-effect @ #x~X>~%" (-> obj effect))
obj
)
;; definition of type generic-merc-ctrl-with-sfx
(deftype generic-merc-ctrl-with-sfx (generic-merc-ctrl)
((sfx-data uint128 11 :offset-assert 240)
)
:method-count-assert 9
:size-assert #x1a0
:flag-assert #x9000001a0
)
;; definition for method 3 of type generic-merc-ctrl-with-sfx
(defmethod inspect generic-merc-ctrl-with-sfx ((obj generic-merc-ctrl-with-sfx))
(format #t "[~8x] ~A~%" obj 'generic-merc-ctrl-with-sfx)
(format #t "~Ttag: #<generic-merc-tag @ #x~X>~%" (-> obj tag))
(format #t "~Tlights: #<vu-lights @ #x~X>~%" (-> obj lights))
(format #t "~Theader: #<merc-ctrl-header @ #x~X>~%" (-> obj header))
(format #t "~Teffect: #<merc-effect @ #x~X>~%" (-> obj effect))
(format #t "~Tsfx-data[11] @ #x~X~%" (-> obj sfx-data))
obj
)
;; definition of type generic-merc-input
(deftype generic-merc-input (structure)
((geo-tag generic-merc-tag :inline :offset-assert 0)
(geo-block uint8 1296 :offset-assert 16)
(byte-header merc-byte-header :inline :offset 16)
(matrix merc-matrix 9 :inline :offset-assert 1312)
(control generic-merc-ctrl-with-sfx :inline :offset-assert 2464)
(end-tag generic-merc-tag :inline :offset-assert 2880)
(shader adgif-shader :inline :offset-assert 2896)
)
:method-count-assert 9
:size-assert #xba0
:flag-assert #x900000ba0
)
;; definition for method 3 of type generic-merc-input
(defmethod inspect generic-merc-input ((obj generic-merc-input))
(format #t "[~8x] ~A~%" obj 'generic-merc-input)
(format #t "~Tgeo-tag: #<generic-merc-tag @ #x~X>~%" (-> obj geo-tag))
(format #t "~Tgeo-block[1296] @ #x~X~%" (-> obj geo-block))
(format #t "~Tbyte-header: #<merc-byte-header @ #x~X>~%" (-> obj geo-block))
(format #t "~Tmatrix[9] @ #x~X~%" (-> obj matrix))
(format
#t
"~Tcontrol: #<generic-merc-ctrl-with-sfx @ #x~X>~%"
(-> obj control)
)
(format #t "~Tend-tag: #<generic-merc-tag @ #x~X>~%" (-> obj end-tag))
(format #t "~Tshader: #<adgif-shader @ #x~X>~%" (-> obj shader))
obj
)
;; definition of type generic-merc-output
(deftype generic-merc-output (structure)
((info gsf-info :inline :offset-assert 0)
(header gsf-header :inline :offset-assert 16)
(index-kick-table uint16 80 :offset-assert 32)
(index-table uint8 160 :offset 32)
(inverse-table uint8 256 :offset-assert 192)
(vertex-table gsf-vertex 72 :inline :offset-assert 448)
)
:method-count-assert 9
:size-assert #xac0
:flag-assert #x900000ac0
)
;; definition for method 3 of type generic-merc-output
(defmethod inspect generic-merc-output ((obj generic-merc-output))
(format #t "[~8x] ~A~%" obj 'generic-merc-output)
(format #t "~Tinfo: #<gsf-info @ #x~X>~%" (-> obj info))
(format #t "~Theader: #<gsf-header @ #x~X>~%" (-> obj header))
(format #t "~Tindex-kick-table[80] @ #x~X~%" (-> obj index-kick-table))
(format #t "~Tindex-table[160] @ #x~X~%" (-> obj index-kick-table))
(format #t "~Tinverse-table[256] @ #x~X~%" (-> obj inverse-table))
(format #t "~Tvertex-table[72] @ #x~X~%" (-> obj vertex-table))
obj
)
;; definition of type generic-merc-dcache
(deftype generic-merc-dcache (structure)
((output-a generic-merc-output :inline :offset-assert 0)
(output-b generic-merc-output :inline :offset-assert 2752)
(inv-table-1 uint8 544 :offset-assert 5504)
(inv-table-7 uint8 544 :offset-assert 6048)
(inv-safety uint8 16 :offset-assert 6592)
(effect-data uint8 1584 :offset-assert 6608)
)
:method-count-assert 9
:size-assert #x2000
:flag-assert #x900002000
)
;; definition for method 3 of type generic-merc-dcache
(defmethod inspect generic-merc-dcache ((obj generic-merc-dcache))
(format #t "[~8x] ~A~%" obj 'generic-merc-dcache)
(format #t "~Toutput-a: #<generic-merc-output @ #x~X>~%" (-> obj output-a))
(format #t "~Toutput-b: #<generic-merc-output @ #x~X>~%" (-> obj output-b))
(format #t "~Tinv-table-1[544] @ #x~X~%" (-> obj inv-table-1))
(format #t "~Tinv-table-7[544] @ #x~X~%" (-> obj inv-table-7))
(format #t "~Tinv-safety[16] @ #x~X~%" (-> obj inv-safety))
(format #t "~Teffect-data[1584] @ #x~X~%" (-> obj effect-data))
obj
)
;; definition of type gm-shadow
(deftype gm-shadow (structure)
((perspective matrix :inline :offset-assert 0)
(isometric matrix :inline :offset-assert 64)
(inv-camera-rot matrix :inline :offset-assert 128)
(envmap-shader adgif-shader :inline :offset-assert 192)
(current-chain uint32 :offset-assert 272)
(next-chain uint32 :offset-assert 276)
(buf-index uint32 :offset-assert 280)
(fragment-count uint32 :offset-assert 284)
(write-limit int32 :offset-assert 288)
(indexed-input-base generic-merc-input :offset-assert 292)
(other-input-base generic-merc-input :offset-assert 296)
(indexed-output-base generic-merc-output :offset-assert 300)
(other-output-base generic-merc-output :offset-assert 304)
(p-input uint32 :offset-assert 308)
(gsf-buf generic-merc-dcache :offset-assert 312)
(p-fheader merc-fp-header :offset-assert 316)
(mercneric-convert basic :offset-assert 320)
(generic-prepare-dma-single basic :offset-assert 324)
(generic-prepare-dma-double basic :offset-assert 328)
(generic-light-proc basic :offset-assert 332)
(generic-envmap-proc basic :offset-assert 336)
(high-speed-reject basic :offset-assert 340)
(hsr-xmult vector :inline :offset-assert 352)
(hsr-ymult vector :inline :offset-assert 368)
)
:method-count-assert 9
:size-assert #x180
:flag-assert #x900000180
)
;; definition for method 3 of type gm-shadow
(defmethod inspect gm-shadow ((obj gm-shadow))
(format #t "[~8x] ~A~%" obj 'gm-shadow)
(format #t "~Tperspective: #<matrix @ #x~X>~%" (-> obj perspective))
(format #t "~Tisometric: #<matrix @ #x~X>~%" (-> obj isometric))
(format #t "~Tinv-camera-rot: #<matrix @ #x~X>~%" (-> obj inv-camera-rot))
(format #t "~Tenvmap-shader: #<adgif-shader @ #x~X>~%" (-> obj envmap-shader))
(format #t "~Tcurrent-chain: ~D~%" (-> obj current-chain))
(format #t "~Tnext-chain: ~D~%" (-> obj next-chain))
(format #t "~Tbuf-index: ~D~%" (-> obj buf-index))
(format #t "~Tfragment-count: ~D~%" (-> obj fragment-count))
(format #t "~Twrite-limit: ~D~%" (-> obj write-limit))
(format
#t
"~Tindexed-input-base: #<generic-merc-input @ #x~X>~%"
(-> obj indexed-input-base)
)
(format
#t
"~Tother-input-base: #<generic-merc-input @ #x~X>~%"
(-> obj other-input-base)
)
(format
#t
"~Tindexed-output-base: #<generic-merc-output @ #x~X>~%"
(-> obj indexed-output-base)
)
(format
#t
"~Tother-output-base: #<generic-merc-output @ #x~X>~%"
(-> obj other-output-base)
)
(format #t "~Tp-input: #x~X~%" (-> obj p-input))
(format #t "~Tgsf-buf: #<generic-merc-dcache @ #x~X>~%" (-> obj gsf-buf))
(format #t "~Tp-fheader: #<merc-fp-header @ #x~X>~%" (-> obj p-fheader))
(format #t "~Tmercneric-convert: ~A~%" (-> obj mercneric-convert))
(format
#t
"~Tgeneric-prepare-dma-single: ~A~%"
(-> obj generic-prepare-dma-single)
)
(format
#t
"~Tgeneric-prepare-dma-double: ~A~%"
(-> obj generic-prepare-dma-double)
)
(format #t "~Tgeneric-light-proc: ~A~%" (-> obj generic-light-proc))
(format #t "~Tgeneric-envmap-proc: ~A~%" (-> obj generic-envmap-proc))
(format #t "~Thigh-speed-reject: ~A~%" (-> obj high-speed-reject))
(format #t "~Thsr-xmult: #<vector @ #x~X>~%" (-> obj hsr-xmult))
(format #t "~Thsr-ymult: #<vector @ #x~X>~%" (-> obj hsr-ymult))
obj
)
;; definition of type generic-merc-work
(deftype generic-merc-work (structure)
((input-a generic-merc-input :inline :offset-assert 0)
(input-b generic-merc-input :inline :offset-assert 2976)
(ctrl generic-merc-ctrl-with-sfx :inline :offset-assert 5952)
(shadow gm-shadow :inline :offset-assert 6368)
(stack uint128 16 :offset-assert 6752)
)
:method-count-assert 9
:size-assert #x1b60
:flag-assert #x900001b60
)
;; definition for method 3 of type generic-merc-work
(defmethod inspect generic-merc-work ((obj generic-merc-work))
(format #t "[~8x] ~A~%" obj 'generic-merc-work)
(format #t "~Tinput-a: #<generic-merc-input @ #x~X>~%" (-> obj input-a))
(format #t "~Tinput-b: #<generic-merc-input @ #x~X>~%" (-> obj input-b))
(format #t "~Tctrl: #<generic-merc-ctrl-with-sfx @ #x~X>~%" (-> obj ctrl))
(format #t "~Tshadow: #<gm-shadow @ #x~X>~%" (-> obj shadow))
(format #t "~Tstack[16] @ #x~X~%" (-> obj stack))
obj
)
;; failed to figure out what this is:
(let ((v0-9 0))
)

726
test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc Normal file
View file

@ -0,0 +1,726 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type ripple-merc-query
(deftype ripple-merc-query (inline-array-class)
((start-vertex int32 :offset-assert 16)
(vertex-skip int32 :offset-assert 20)
(vertex-count int32 :offset-assert 24)
(current-loc int32 :offset-assert 28)
(data2 uint8 :dynamic :offset-assert 32)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type ripple-merc-query
(defmethod inspect ripple-merc-query ((obj ripple-merc-query))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Tallocated-length: ~D~%" (-> obj allocated-length))
(format #t "~Tstart-vertex: ~D~%" (-> obj start-vertex))
(format #t "~Tvertex-skip: ~D~%" (-> obj vertex-skip))
(format #t "~Tvertex-count: ~D~%" (-> obj vertex-count))
(format #t "~Tcurrent-loc: ~D~%" (-> obj current-loc))
(format #t "~Tdata[0] @ #x~X~%" (&-> obj data 20))
obj
)
;; failed to figure out what this is:
(set! (-> ripple-merc-query heap-base) (the-as uint 16))
;; definition of type merc-byte-header
(deftype merc-byte-header (structure)
((srcdest-off uint8 :offset-assert 0)
(rgba-off uint8 :offset-assert 1)
(lump-off uint8 :offset-assert 2)
(fp-off uint8 :offset-assert 3)
(mat1-cnt uint8 :offset-assert 4)
(mat2-cnt uint8 :offset-assert 5)
(mat3-cnt uint8 :offset-assert 6)
(samecopy-cnt uint8 :offset-assert 7)
(crosscopy-cnt uint8 :offset-assert 8)
(strip-len uint8 :offset-assert 9)
(mm-quadword-fp-off uint8 :offset-assert 10)
(mm-quadword-size uint8 :offset-assert 11)
(perc-off uint8 :offset-assert 12)
(mat-slot uint8 10 :offset-assert 13)
)
:method-count-assert 9
:size-assert #x17
:flag-assert #x900000017
)
;; definition for method 3 of type merc-byte-header
(defmethod inspect merc-byte-header ((obj merc-byte-header))
(format #t "[~8x] ~A~%" obj 'merc-byte-header)
(format #t "~Tsrcdest-off: ~D~%" (-> obj srcdest-off))
(format #t "~Trgba-off: ~D~%" (-> obj rgba-off))
(format #t "~Tlump-off: ~D~%" (-> obj lump-off))
(format #t "~Tfp-off: ~D~%" (-> obj fp-off))
(format #t "~Tmat1-cnt: ~D~%" (-> obj mat1-cnt))
(format #t "~Tmat2-cnt: ~D~%" (-> obj mat2-cnt))
(format #t "~Tmat3-cnt: ~D~%" (-> obj mat3-cnt))
(format #t "~Tsamecopy-cnt: ~D~%" (-> obj samecopy-cnt))
(format #t "~Tcrosscopy-cnt: ~D~%" (-> obj crosscopy-cnt))
(format #t "~Tstrip-len: ~D~%" (-> obj strip-len))
(format #t "~Tmm-quadword-fp-off: ~D~%" (-> obj mm-quadword-fp-off))
(format #t "~Tmm-quadword-size: ~D~%" (-> obj mm-quadword-size))
(format #t "~Tperc-off: ~D~%" (-> obj perc-off))
(format #t "~Tmat-slot[10] @ #x~X~%" (-> obj mat-slot))
obj
)
;; definition of type merc-fragment
(deftype merc-fragment (structure)
((header merc-byte-header :inline :offset-assert 0)
(rest uint8 1 :offset-assert 23)
)
:method-count-assert 10
:size-assert #x18
:flag-assert #xa00000018
(:methods
(dummy-9 () none 9)
)
)
;; definition for method 3 of type merc-fragment
(defmethod inspect merc-fragment ((obj merc-fragment))
(format #t "[~8x] ~A~%" obj 'merc-fragment)
(format #t "~Theader: #<merc-byte-header @ #x~X>~%" (-> obj header))
(format #t "~Trest[1] @ #x~X~%" (-> obj rest))
obj
)
;; definition of type merc-vtx
(deftype merc-vtx (structure)
((mat-0 uint8 :offset-assert 0)
(mat-1 uint8 :offset-assert 1)
(nrm-x uint8 :offset-assert 2)
(pos-x uint8 :offset-assert 3)
(dst-0 uint8 :offset-assert 4)
(dst-1 uint8 :offset-assert 5)
(nrm-y uint8 :offset-assert 6)
(pos-y uint8 :offset-assert 7)
(tex-s uint8 :offset-assert 8)
(tex-t uint8 :offset-assert 9)
(nrm-z uint8 :offset-assert 10)
(pos-z uint8 :offset-assert 11)
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type merc-vtx
(defmethod inspect merc-vtx ((obj merc-vtx))
(format #t "[~8x] ~A~%" obj 'merc-vtx)
(format #t "~Tmat-0: ~D~%" (-> obj mat-0))
(format #t "~Tmat-1: ~D~%" (-> obj mat-1))
(format #t "~Tnrm-x: ~D~%" (-> obj nrm-x))
(format #t "~Tpos-x: ~D~%" (-> obj pos-x))
(format #t "~Tdst-0: ~D~%" (-> obj dst-0))
(format #t "~Tdst-1: ~D~%" (-> obj dst-1))
(format #t "~Tnrm-y: ~D~%" (-> obj nrm-y))
(format #t "~Tpos-y: ~D~%" (-> obj pos-y))
(format #t "~Ttex-s: ~D~%" (-> obj tex-s))
(format #t "~Ttex-t: ~D~%" (-> obj tex-t))
(format #t "~Tnrm-z: ~D~%" (-> obj nrm-z))
(format #t "~Tpos-z: ~D~%" (-> obj pos-z))
obj
)
;; definition of type merc-fp-header
(deftype merc-fp-header (structure)
((x-add float :offset-assert 0)
(y-add float :offset-assert 4)
(z-add float :offset-assert 8)
(shader-cnt uint8 :offset-assert 12)
(kick-info-offset uint8 :offset-assert 13)
(kick-info-step uint8 :offset-assert 14)
(hword-cnt uint8 :offset-assert 15)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type merc-fp-header
(defmethod inspect merc-fp-header ((obj merc-fp-header))
(format #t "[~8x] ~A~%" obj 'merc-fp-header)
(format #t "~Tx-add: ~f~%" (-> obj x-add))
(format #t "~Ty-add: ~f~%" (-> obj y-add))
(format #t "~Tz-add: ~f~%" (-> obj z-add))
(format #t "~Tshader-cnt: ~D~%" (-> obj shader-cnt))
(format #t "~Tkick-info-offset: ~D~%" (-> obj kick-info-offset))
(format #t "~Tkick-info-step: ~D~%" (-> obj kick-info-step))
(format #t "~Thword-cnt: ~D~%" (-> obj hword-cnt))
obj
)
;; definition for function merc-fragment-fp-data
;; INFO: Return type mismatch int vs pointer.
(defun merc-fragment-fp-data ((arg0 merc-fragment))
(the-as
pointer
(+
(the-as uint arg0)
(the-as uint (* (-> arg0 header mm-quadword-fp-off) 16))
)
)
)
;; definition of type merc-mat-dest
(deftype merc-mat-dest (structure)
((matrix-number uint8 :offset-assert 0)
(matrix-dest uint8 :offset-assert 1)
)
:method-count-assert 9
:size-assert #x2
:flag-assert #x900000002
)
;; definition for method 3 of type merc-mat-dest
(defmethod inspect merc-mat-dest ((obj merc-mat-dest))
(format #t "[~8x] ~A~%" obj 'merc-mat-dest)
(format #t "~Tmatrix-number: ~D~%" (-> obj matrix-number))
(format #t "~Tmatrix-dest: ~D~%" (-> obj matrix-dest))
obj
)
;; definition of type merc-fragment-control
(deftype merc-fragment-control (structure)
((unsigned-four-count uint8 :offset-assert 0)
(lump-four-count uint8 :offset-assert 1)
(fp-qwc uint8 :offset-assert 2)
(mat-xfer-count uint8 :offset-assert 3)
(mat-dest-data uint8 :dynamic :offset-assert 4)
)
:method-count-assert 9
:size-assert #x4
:flag-assert #x900000004
)
;; definition for method 3 of type merc-fragment-control
(defmethod inspect merc-fragment-control ((obj merc-fragment-control))
(format #t "[~8x] ~A~%" obj 'merc-fragment-control)
(format #t "~Tunsigned-four-count: ~D~%" (-> obj unsigned-four-count))
(format #t "~Tlump-four-count: ~D~%" (-> obj lump-four-count))
(format #t "~Tfp-qwc: ~D~%" (-> obj fp-qwc))
(format #t "~Tmat-xfer-count: ~D~%" (-> obj mat-xfer-count))
(format #t "~Tmat-dest-data[0] @ #x~X~%" (-> obj mat-dest-data))
obj
)
;; definition of type merc-blend-data
(deftype merc-blend-data (structure)
((int8-data int8 :dynamic :offset-assert 0)
)
:method-count-assert 9
:size-assert #x0
:flag-assert #x900000000
)
;; definition for method 3 of type merc-blend-data
(defmethod inspect merc-blend-data ((obj merc-blend-data))
(format #t "[~8x] ~A~%" obj 'merc-blend-data)
(format #t "~Tint8-data[0] @ #x~X~%" (-> obj int8-data))
obj
)
;; definition of type merc-blend-ctrl
(deftype merc-blend-ctrl (structure)
((blend-vtx-count uint8 :offset-assert 0)
(nonzero-index-count uint8 :offset-assert 1)
(bt-index uint8 :dynamic :offset-assert 2)
)
:method-count-assert 9
:size-assert #x2
:flag-assert #x900000002
)
;; definition for method 3 of type merc-blend-ctrl
(defmethod inspect merc-blend-ctrl ((obj merc-blend-ctrl))
(format #t "[~8x] ~A~%" obj 'merc-blend-ctrl)
(format #t "~Tblend-vtx-count: ~D~%" (-> obj blend-vtx-count))
(format #t "~Tnonzero-index-count: ~D~%" (-> obj nonzero-index-count))
(format #t "~Tbt-index[0] @ #x~X~%" (-> obj bt-index))
obj
)
;; definition of type mei-envmap-tint
(deftype mei-envmap-tint (structure)
((fade0 float :offset-assert 0)
(fade1 float :offset-assert 4)
(tint uint32 :offset-assert 8)
(dummy int32 :offset-assert 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type mei-envmap-tint
(defmethod inspect mei-envmap-tint ((obj mei-envmap-tint))
(format #t "[~8x] ~A~%" obj 'mei-envmap-tint)
(format #t "~Tfade0: ~f~%" (-> obj fade0))
(format #t "~Tfade1: ~f~%" (-> obj fade1))
(format #t "~Ttint: ~D~%" (-> obj tint))
(format #t "~Tdummy: ~D~%" (-> obj dummy))
obj
)
;; definition of type mei-texture-scroll
(deftype mei-texture-scroll (structure)
((max-dist float :offset-assert 0)
(st-int-scale uint8 :offset-assert 4)
(time-factor uint8 :offset-assert 5)
(scroll-dir uint8 :offset-assert 6)
(cached-time uint8 :offset-assert 7)
(time-delta uint8 :offset-assert 8)
(dummy uint8 7 :offset-assert 9)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type mei-texture-scroll
(defmethod inspect mei-texture-scroll ((obj mei-texture-scroll))
(format #t "[~8x] ~A~%" obj 'mei-texture-scroll)
(format #t "~Tmax-dist: ~f~%" (-> obj max-dist))
(format #t "~Tst-int-scale: ~D~%" (-> obj st-int-scale))
(format #t "~Ttime-factor: ~D~%" (-> obj time-factor))
(format #t "~Tscroll-dir: ~D~%" (-> obj scroll-dir))
(format #t "~Tcached-time: ~D~%" (-> obj cached-time))
(format #t "~Ttime-delta: ~D~%" (-> obj time-delta))
(format #t "~Tdummy[7] @ #x~X~%" (-> obj dummy))
obj
)
;; definition of type mei-ripple
(deftype mei-ripple (structure)
((x-base float :offset-assert 0)
(z-base float :offset-assert 4)
(grid-size float :offset-assert 8)
(angle float :offset-assert 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type mei-ripple
(defmethod inspect mei-ripple ((obj mei-ripple))
(format #t "[~8x] ~A~%" obj 'mei-ripple)
(format #t "~Tx-base: ~f~%" (-> obj x-base))
(format #t "~Tz-base: ~f~%" (-> obj z-base))
(format #t "~Tgrid-size: ~f~%" (-> obj grid-size))
(format #t "~Tangle: ~f~%" (-> obj angle))
obj
)
;; definition of type merc-extra-info
(deftype merc-extra-info (structure)
((envmap-tint-offset uint8 :offset-assert 0)
(shader-offset uint8 :offset-assert 1)
(texture-scroll-offset uint8 :offset-assert 2)
(ripple-offset uint8 :offset-assert 3)
(dummy uint8 12 :offset-assert 4)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type merc-extra-info
(defmethod inspect merc-extra-info ((obj merc-extra-info))
(format #t "[~8x] ~A~%" obj 'merc-extra-info)
(format #t "~Tenvmap-tint-offset: ~D~%" (-> obj envmap-tint-offset))
(format #t "~Tshader-offset: ~D~%" (-> obj shader-offset))
(format #t "~Ttexture-scroll-offset: ~D~%" (-> obj texture-scroll-offset))
(format #t "~Tripple-offset: ~D~%" (-> obj ripple-offset))
(format #t "~Tdummy[12] @ #x~X~%" (-> obj dummy))
obj
)
;; definition of type merc-effect
(deftype merc-effect (structure)
((frag-geo merc-fragment :offset-assert 0)
(frag-ctrl merc-fragment-control :offset-assert 4)
(blend-data merc-blend-data :offset-assert 8)
(blend-ctrl merc-blend-ctrl :offset-assert 12)
(dummy0 uint8 :offset-assert 16)
(effect-bits uint8 :offset-assert 17)
(frag-count uint16 :offset-assert 18)
(blend-frag-count uint16 :offset-assert 20)
(tri-count uint16 :offset-assert 22)
(dvert-count uint16 :offset-assert 24)
(dummy1 uint8 :offset-assert 26)
(envmap-usage uint8 :offset-assert 27)
(extra-info merc-extra-info :offset-assert 28)
)
:method-count-assert 10
:size-assert #x20
:flag-assert #xa00000020
(:methods
(dummy-9 () none 9)
)
)
;; definition for method 3 of type merc-effect
(defmethod inspect merc-effect ((obj merc-effect))
(format #t "[~8x] ~A~%" obj 'merc-effect)
(format #t "~Tfrag-geo: #<merc-fragment @ #x~X>~%" (-> obj frag-geo))
(format
#t
"~Tfrag-ctrl: #<merc-fragment-control @ #x~X>~%"
(-> obj frag-ctrl)
)
(format #t "~Tblend-data: #<merc-blend-data @ #x~X>~%" (-> obj blend-data))
(format #t "~Tblend-ctrl: #<merc-blend-ctrl @ #x~X>~%" (-> obj blend-ctrl))
(format #t "~Tdummy0: ~D~%" (-> obj dummy0))
(format #t "~Teffect-bits: ~D~%" (-> obj effect-bits))
(format #t "~Tfrag-count: ~D~%" (-> obj frag-count))
(format #t "~Tblend-frag-count: ~D~%" (-> obj blend-frag-count))
(format #t "~Ttri-count: ~D~%" (-> obj tri-count))
(format #t "~Tdvert-count: ~D~%" (-> obj dvert-count))
(format #t "~Tdummy1: ~D~%" (-> obj dummy1))
(format #t "~Tenvmap-usage: ~D~%" (-> obj envmap-usage))
(format #t "~Textra-info: #<merc-extra-info @ #x~X>~%" (-> obj extra-info))
obj
)
;; definition of type merc-eye-ctrl
(deftype merc-eye-ctrl (structure)
((eye-slot int8 :offset-assert 0)
(shader-offset int8 :offset-assert 1)
(shader-count int8 :offset-assert 2)
(iris-shader adgif-shader :inline :offset-assert 16)
(pupil-shader adgif-shader :inline :offset-assert 96)
(lid-shader adgif-shader :inline :offset-assert 176)
(shader adgif-shader 3 :inline :offset 16)
)
:method-count-assert 9
:size-assert #x100
:flag-assert #x900000100
)
;; definition for method 3 of type merc-eye-ctrl
(defmethod inspect merc-eye-ctrl ((obj merc-eye-ctrl))
(format #t "[~8x] ~A~%" obj 'merc-eye-ctrl)
(format #t "~Teye-slot: ~D~%" (-> obj eye-slot))
(format #t "~Tshader-offset: ~D~%" (-> obj shader-offset))
(format #t "~Tshader-count: ~D~%" (-> obj shader-count))
(format #t "~Tshader[3] @ #x~X~%" (-> obj iris-shader))
(format #t "~Tiris-shader: #<adgif-shader @ #x~X>~%" (-> obj iris-shader))
(format #t "~Tpupil-shader: #<adgif-shader @ #x~X>~%" (-> obj pupil-shader))
(format #t "~Tlid-shader: #<adgif-shader @ #x~X>~%" (-> obj lid-shader))
obj
)
;; definition of type merc-eye-anim-frame
(deftype merc-eye-anim-frame (structure)
((pupil-trans-x int8 :offset-assert 0)
(pupil-trans-y int8 :offset-assert 1)
(blink int8 :offset-assert 2)
(iris-scale int8 :offset 4)
(pupil-scale int8 :offset-assert 5)
(lid-scale int8 :offset-assert 6)
(dword uint64 :offset 0)
)
:method-count-assert 9
:size-assert #x8
:flag-assert #x900000008
)
;; definition for method 3 of type merc-eye-anim-frame
(defmethod inspect merc-eye-anim-frame ((obj merc-eye-anim-frame))
(format #t "[~8x] ~A~%" obj 'merc-eye-anim-frame)
(format #t "~Tpupil-trans-x: ~D~%" (-> obj pupil-trans-x))
(format #t "~Tpupil-trans-y: ~D~%" (-> obj pupil-trans-y))
(format #t "~Tblink: ~D~%" (-> obj blink))
(format #t "~Tiris-scale: ~D~%" (-> obj iris-scale))
(format #t "~Tpupil-scale: ~D~%" (-> obj pupil-scale))
(format #t "~Tlid-scale: ~D~%" (-> obj lid-scale))
(format #t "~Tdword: ~D~%" (-> obj dword))
obj
)
;; definition of type merc-eye-anim-block
(deftype merc-eye-anim-block (structure)
((max-frame int16 :offset-assert 0)
(data uint8 :dynamic :offset 8)
)
:method-count-assert 9
:size-assert #x8
:flag-assert #x900000008
)
;; definition for method 3 of type merc-eye-anim-block
(defmethod inspect merc-eye-anim-block ((obj merc-eye-anim-block))
(format #t "[~8x] ~A~%" obj 'merc-eye-anim-block)
(format #t "~Tmax-frame: ~D~%" (-> obj max-frame))
(format #t "~Tdata[0] @ #x~X~%" (-> obj data))
obj
)
;; definition of type merc-ctrl-header
(deftype merc-ctrl-header (structure)
((xyz-scale float :offset-assert 0)
(st-magic uint32 :offset-assert 4)
(st-out-a uint32 :offset-assert 8)
(st-out-b uint32 :offset-assert 12)
(st-vif-add uint32 :offset-assert 16)
(st-int-off uint16 :offset-assert 20)
(st-int-scale uint16 :offset-assert 22)
(effect-count uint32 :offset-assert 24)
(blend-target-count uint32 :offset-assert 28)
(fragment-count uint16 :offset-assert 32)
(tri-count uint16 :offset-assert 34)
(matrix-count uint8 :offset-assert 36)
(shader-count uint8 :offset-assert 37)
(transform-vertex-count uint16 :offset-assert 38)
(dvert-count uint16 :offset-assert 40)
(one-mat-count uint16 :offset-assert 42)
(two-mat-count uint16 :offset-assert 44)
(two-mat-reuse-count uint16 :offset-assert 46)
(three-mat-count uint16 :offset-assert 48)
(three-mat-reuse-count uint16 :offset-assert 50)
(shader-upload-count uint8 :offset-assert 52)
(matrix-upload-count uint8 :offset-assert 53)
(same-copy-count uint16 :offset-assert 54)
(cross-copy-count uint16 :offset-assert 56)
(num-verts uint16 :offset-assert 58)
(longest-edge float :offset-assert 60)
(eye-ctrl merc-eye-ctrl :offset-assert 64)
(masks uint32 3 :offset-assert 68)
(dummy-bytes uint8 48 :offset 32)
(envmap-tint uint32 :offset 32)
(query basic :offset 36)
(needs-clip uint8 :offset 40)
(use-isometric uint8 :offset 41)
(use-attached-shader uint8 :offset 42)
(display-triangles uint8 :offset 43)
(death-vertex-skip uint16 :offset 44)
(death-start-vertex uint16 :offset 46)
(death-effect uint32 :offset 48)
(use-translucent uint8 :offset 52)
(display-this-fragment uint8 :offset 53)
)
:method-count-assert 9
:size-assert #x50
:flag-assert #x900000050
)
;; definition for method 3 of type merc-ctrl-header
(defmethod inspect merc-ctrl-header ((obj merc-ctrl-header))
(format #t "[~8x] ~A~%" obj 'merc-ctrl-header)
(format #t "~Txyz-scale: #x~X~%" (-> obj xyz-scale))
(format #t "~Tst-magic: #x~X~%" (-> obj st-magic))
(format #t "~Tst-out-a: #x~X~%" (-> obj st-out-a))
(format #t "~Tst-out-b: #x~X~%" (-> obj st-out-b))
(format #t "~Tst-vif-add: #x~X~%" (-> obj st-vif-add))
(format #t "~Tst-int-off: ~D~%" (-> obj st-int-off))
(format #t "~Tst-int-scale: ~D~%" (-> obj st-int-scale))
(format #t "~Teffect-count: ~D~%" (-> obj effect-count))
(format #t "~Tblend-target-count: ~D~%" (-> obj blend-target-count))
(format #t "~Tfragment-count: ~D~%" (-> obj fragment-count))
(format #t "~Ttri-count: ~D~%" (-> obj tri-count))
(format #t "~Tmatrix-count: ~D~%" (-> obj matrix-count))
(format #t "~Tshader-count: ~D~%" (-> obj shader-count))
(format #t "~Ttransform-vertex-count: ~D~%" (-> obj transform-vertex-count))
(format #t "~Tdvert-count: ~D~%" (-> obj dvert-count))
(format #t "~Tone-mat-count: ~D~%" (-> obj one-mat-count))
(format #t "~Ttwo-mat-count: ~D~%" (-> obj two-mat-count))
(format #t "~Ttwo-mat-reuse-count: ~D~%" (-> obj two-mat-reuse-count))
(format #t "~Tthree-mat-count: ~D~%" (-> obj three-mat-count))
(format #t "~Tthree-mat-reuse-count: ~D~%" (-> obj three-mat-reuse-count))
(format #t "~Tshader-upload-count: ~D~%" (-> obj shader-upload-count))
(format #t "~Tmatrix-upload-count: ~D~%" (-> obj matrix-upload-count))
(format #t "~Tsame-copy-count: ~D~%" (-> obj same-copy-count))
(format #t "~Tcross-copy-count: ~D~%" (-> obj cross-copy-count))
(format #t "~Tnum-verts: ~D~%" (-> obj num-verts))
(format #t "~Tlongest-edge: ~f~%" (-> obj longest-edge))
(format #t "~Teye-ctrl: #<merc-eye-ctrl @ #x~X>~%" (-> obj eye-ctrl))
(format #t "~Tmasks[3] @ #x~X~%" (-> obj masks))
(format #t "~Tdummy-bytes[48] @ #x~X~%" (&-> obj fragment-count))
(format #t "~Tenvmap-tint: ~D~%" (-> obj envmap-tint))
(format #t "~Tquery: ~A~%" (-> obj query))
(format #t "~Tneeds-clip: ~D~%" (-> obj dummy-bytes 8))
(format #t "~Tuse-isometric: ~D~%" (-> obj dummy-bytes 9))
(format #t "~Tuse-attached-shader: ~D~%" (-> obj dummy-bytes 10))
(format #t "~Tdisplay-triangles: ~D~%" (-> obj dummy-bytes 11))
(format #t "~Tdeath-vertex-skip: ~D~%" (-> obj two-mat-count))
(format #t "~Tdeath-start-vertex: ~D~%" (-> obj two-mat-reuse-count))
(format #t "~Tdeath-effect: ~D~%" (-> obj death-effect))
(format #t "~Tuse-translucent: ~D~%" (-> obj shader-upload-count))
(format #t "~Tdisplay-this-fragment: ~D~%" (-> obj matrix-upload-count))
obj
)
;; definition of type merc-ctrl
(deftype merc-ctrl (art-element)
((num-joints int32 :offset 20)
(header merc-ctrl-header :inline :offset-assert 32)
(effect uint8 :dynamic :offset-assert 112)
)
:method-count-assert 13
:size-assert #x70
:flag-assert #xd00000070
)
;; definition for method 3 of type merc-ctrl
(defmethod inspect merc-ctrl ((obj merc-ctrl))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Textra: ~A~%" (-> obj extra))
(format #t "~Tnum-joints: ~D~%" (-> obj num-joints))
(format #t "~Theader: #<merc-ctrl-header @ #x~X>~%" (-> obj header))
(format #t "~Teffect[0] @ #x~X~%" (-> obj effect))
obj
)
;; definition of type merc-vu1-low-mem
(deftype merc-vu1-low-mem (structure)
((tri-strip-gif qword :inline :offset-assert 0)
(ad-gif qword :inline :offset-assert 16)
(hvdf-offset vector :inline :offset-assert 32)
(perspective uint128 4 :offset-assert 48)
(fog vector :inline :offset-assert 112)
)
:method-count-assert 9
:size-assert #x80
:flag-assert #x900000080
)
;; definition for method 3 of type merc-vu1-low-mem
(defmethod inspect merc-vu1-low-mem ((obj merc-vu1-low-mem))
(format #t "[~8x] ~A~%" obj 'merc-vu1-low-mem)
(format #t "~Ttri-strip-gif: #<qword @ #x~X>~%" (-> obj tri-strip-gif))
(format #t "~Tad-gif: #<qword @ #x~X>~%" (-> obj ad-gif))
(format #t "~Thvdf-offset: #<vector @ #x~X>~%" (-> obj hvdf-offset))
(format #t "~Tperspective[4] @ #x~X~%" (-> obj perspective))
(format #t "~Tfog: #<vector @ #x~X>~%" (-> obj fog))
obj
)
;; definition of type ripple-wave
(deftype ripple-wave (structure)
((scale float :offset-assert 0)
(offs float :offset-assert 4)
(xdiv int16 :offset-assert 8)
(zdiv int16 :offset-assert 10)
(speed float :offset-assert 12)
(xmul float :offset-assert 16)
(zmul float :offset-assert 20)
(delta float :offset-assert 24)
)
:pack-me
:method-count-assert 9
:size-assert #x1c
:flag-assert #x90000001c
)
;; definition for method 3 of type ripple-wave
(defmethod inspect ripple-wave ((obj ripple-wave))
(format #t "[~8x] ~A~%" obj 'ripple-wave)
(format #t "~Tscale: ~f~%" (-> obj scale))
(format #t "~Toffs: ~f~%" (-> obj offs))
(format #t "~Txdiv: ~D~%" (-> obj xdiv))
(format #t "~Tzdiv: ~D~%" (-> obj zdiv))
(format #t "~Tspeed: ~f~%" (-> obj speed))
(format #t "~Txmul: ~f~%" (-> obj xmul))
(format #t "~Tzmul: ~f~%" (-> obj zmul))
(format #t "~Tdelta: ~f~%" (-> obj delta))
obj
)
;; definition of type ripple-wave-set
(deftype ripple-wave-set (basic)
((count int32 :offset-assert 4)
(converted basic :offset-assert 8)
(frame-save uint32 :offset-assert 12)
(normal-scale float :offset-assert 16)
(wave ripple-wave 4 :inline :offset-assert 20)
)
:method-count-assert 9
:size-assert #x84
:flag-assert #x900000084
)
;; definition for method 3 of type ripple-wave-set
(defmethod inspect ripple-wave-set ((obj ripple-wave-set))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tcount: ~D~%" (-> obj count))
(format #t "~Tconverted: ~A~%" (-> obj converted))
(format #t "~Tframe-save: ~D~%" (-> obj frame-save))
(format #t "~Tnormal-scale: ~f~%" (-> obj normal-scale))
(format #t "~Twave[4] @ #x~X~%" (-> obj wave))
obj
)
;; definition of type ripple-control
(deftype ripple-control (basic)
((global-scale float :offset-assert 4)
(last-frame-scale float :offset-assert 8)
(close-fade-dist float :offset-assert 12)
(far-fade-dist float :offset-assert 16)
(faded-scale float :offset-assert 20)
(individual-normal-scale float :offset-assert 24)
(waveform basic :offset-assert 28)
(send-query basic :offset-assert 32)
(query basic :offset-assert 36)
)
:method-count-assert 9
:size-assert #x28
:flag-assert #x900000028
(:methods
(new (symbol type) _type_ 0)
)
)
;; definition for method 3 of type ripple-control
(defmethod inspect ripple-control ((obj ripple-control))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tglobal-scale: ~f~%" (-> obj global-scale))
(format #t "~Tlast-frame-scale: ~f~%" (-> obj last-frame-scale))
(format #t "~Tclose-fade-dist: ~f~%" (-> obj close-fade-dist))
(format #t "~Tfar-fade-dist: ~f~%" (-> obj far-fade-dist))
(format #t "~Tfaded-scale: ~f~%" (-> obj faded-scale))
(format #t "~Tindividual-normal-scale: ~f~%" (-> obj individual-normal-scale))
(format #t "~Twaveform: ~A~%" (-> obj waveform))
(format #t "~Tsend-query: ~A~%" (-> obj send-query))
(format #t "~Tquery: ~A~%" (-> obj query))
obj
)
;; definition for method 0 of type ripple-control
(defmethod new ripple-control ((allocation symbol) (type-to-make type))
(let
((obj
(object-new allocation type-to-make (the-as int (-> type-to-make size)))
)
)
(set! (-> obj global-scale) 0.0)
(set! (-> obj last-frame-scale) -0.001)
(set! (-> obj close-fade-dist) 4096000000.0)
(set! (-> obj far-fade-dist) 8192000000.0)
(set! (-> obj faded-scale) -0.001)
(set! (-> obj waveform) #f)
(set! (-> obj individual-normal-scale) 1.0)
(set! (-> obj send-query) #f)
(set! (-> obj query) #f)
obj
)
)
;; failed to figure out what this is:
(let ((v0-23 0))
)

472
test/decompiler/reference/engine/gfx/tie/generic-tie-h_REF.gc Normal file
View file

@ -0,0 +1,472 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type generic-tie-instance
(deftype generic-tie-instance (structure)
((matrix-tag dma-packet :inline :offset-assert 0)
(matrix-data vector 6 :inline :offset-assert 16)
(index-tag dma-packet :inline :offset-assert 112)
(indices uint8 224 :offset-assert 128)
(end-tag dma-packet :inline :offset-assert 352)
)
:method-count-assert 9
:size-assert #x170
:flag-assert #x900000170
)
;; definition for method 3 of type generic-tie-instance
(defmethod inspect generic-tie-instance ((obj generic-tie-instance))
(format #t "[~8x] ~A~%" obj 'generic-tie-instance)
(format #t "~Tmatrix-tag: #<dma-packet @ #x~X>~%" (-> obj matrix-tag))
(format #t "~Tmatrix-data[6] @ #x~X~%" (-> obj matrix-data))
(format #t "~Tindex-tag: #<dma-packet @ #x~X>~%" (-> obj index-tag))
(format #t "~Tindices[224] @ #x~X~%" (-> obj indices))
(format #t "~Tend-tag: #<dma-packet @ #x~X>~%" (-> obj end-tag))
obj
)
;; definition of type generic-tie-input
(deftype generic-tie-input (structure)
((palette-tag dma-packet :inline :offset-assert 0)
(palette rgba 128 :offset-assert 16)
(model-tag dma-packet :inline :offset-assert 528)
(model vector 146 :inline :offset-assert 544)
(matrix-tag dma-packet :inline :offset-assert 2880)
(matrix-data vector 6 :inline :offset-assert 2896)
(index-tag dma-packet :inline :offset-assert 2992)
(indices uint8 224 :offset-assert 3008)
(end-tag dma-packet :inline :offset-assert 3232)
)
:method-count-assert 9
:size-assert #xcb0
:flag-assert #x900000cb0
)
;; definition for method 3 of type generic-tie-input
(defmethod inspect generic-tie-input ((obj generic-tie-input))
(format #t "[~8x] ~A~%" obj 'generic-tie-input)
(format #t "~Tpalette-tag: #<dma-packet @ #x~X>~%" (-> obj palette-tag))
(format #t "~Tpalette[128] @ #x~X~%" (-> obj palette))
(format #t "~Tmodel-tag: #<dma-packet @ #x~X>~%" (-> obj model-tag))
(format #t "~Tmodel[146] @ #x~X~%" (-> obj model))
(format #t "~Tmatrix-tag: #<dma-packet @ #x~X>~%" (-> obj matrix-tag))
(format #t "~Tmatrix-data[6] @ #x~X~%" (-> obj matrix-data))
(format #t "~Tindex-tag: #<dma-packet @ #x~X>~%" (-> obj index-tag))
(format #t "~Tindices[224] @ #x~X~%" (-> obj indices))
(format #t "~Tend-tag: #<dma-packet @ #x~X>~%" (-> obj end-tag))
obj
)
;; definition of type generic-tie-run-control
(deftype generic-tie-run-control (structure)
((skip-bp2 uint8 :offset-assert 0)
(skip-ips uint8 :offset-assert 1)
(gifbuf-skip uint8 :offset-assert 2)
(strips uint8 :offset-assert 3)
(target-bp1 uint8 :offset-assert 4)
(target-bp2 uint8 :offset-assert 5)
(target-ip1 uint8 :offset-assert 6)
(target-ip2 uint8 :offset-assert 7)
(target-bps uint8 :offset-assert 8)
(target-ips uint8 :offset-assert 9)
(is-generic uint8 :offset-assert 10)
(reserved uint8 :offset-assert 11)
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type generic-tie-run-control
(defmethod inspect generic-tie-run-control ((obj generic-tie-run-control))
(format #t "[~8x] ~A~%" obj 'generic-tie-run-control)
(format #t "~Tskip-bp2: ~D~%" (-> obj skip-bp2))
(format #t "~Tskip-ips: ~D~%" (-> obj skip-ips))
(format #t "~Tgifbuf-skip: ~D~%" (-> obj gifbuf-skip))
(format #t "~Tstrips: ~D~%" (-> obj strips))
(format #t "~Ttarget-bp1: ~D~%" (-> obj target-bp1))
(format #t "~Ttarget-bp2: ~D~%" (-> obj target-bp2))
(format #t "~Ttarget-ip1: ~D~%" (-> obj target-ip1))
(format #t "~Ttarget-ip2: ~D~%" (-> obj target-ip2))
(format #t "~Ttarget-bps: ~D~%" (-> obj target-bps))
(format #t "~Ttarget-ips: ~D~%" (-> obj target-ips))
(format #t "~Tis-generic: ~D~%" (-> obj is-generic))
(format #t "~Treserved: ~D~%" (-> obj reserved))
obj
)
;; definition of type generic-tie-base-point
(deftype generic-tie-base-point (structure)
((x int16 :offset-assert 0)
(y int16 :offset-assert 2)
(z int16 :offset-assert 4)
(d0 int16 :offset-assert 6)
(vtx uint64 :offset 0)
(u int16 :offset-assert 8)
(v int16 :offset-assert 10)
(tex uint32 :offset 8)
(w int16 :offset-assert 12)
(d1 int16 :offset-assert 14)
(data uint16 8 :offset 0)
(quad uint128 :offset 0)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type generic-tie-base-point
;; Used lq/sq
(defmethod inspect generic-tie-base-point ((obj generic-tie-base-point))
(format #t "[~8x] ~A~%" obj 'generic-tie-base-point)
(format #t "~Tdata[8] @ #x~X~%" (&-> obj x))
(format #t "~Tquad: ~D~%" (-> obj quad))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
(format #t "~Td0: ~D~%" (-> obj d0))
(format #t "~Tvtx: ~D~%" (-> obj vtx))
(format #t "~Tu: ~D~%" (-> obj u))
(format #t "~Tv: ~D~%" (-> obj v))
(format #t "~Ttex: ~D~%" (-> obj tex))
(format #t "~Tw: ~D~%" (-> obj w))
(format #t "~Td1: ~D~%" (-> obj d1))
obj
)
;; definition of type generic-tie-bps
(deftype generic-tie-bps (structure)
((bp generic-tie-base-point 4 :inline :offset-assert 0)
)
:method-count-assert 9
:size-assert #x40
:flag-assert #x900000040
)
;; definition for method 3 of type generic-tie-bps
(defmethod inspect generic-tie-bps ((obj generic-tie-bps))
(format #t "[~8x] ~A~%" obj 'generic-tie-bps)
(format #t "~Tbp[4] @ #x~X~%" (-> obj bp))
obj
)
;; definition of type generic-tie-interp-point
(deftype generic-tie-interp-point (structure)
((x int16 :offset-assert 0)
(y int16 :offset-assert 2)
(z int16 :offset-assert 4)
(d0 int16 :offset-assert 6)
(vtx0 uint64 :offset 0)
(dx int16 :offset-assert 8)
(dy int16 :offset-assert 10)
(dz int16 :offset-assert 12)
(unused int16 :offset-assert 14)
(vtx1 uint64 :offset 8)
(u int16 :offset-assert 16)
(v int16 :offset-assert 18)
(tex uint32 :offset 16)
(w int16 :offset-assert 20)
(d1 int16 :offset-assert 22)
(data uint16 12 :offset 0)
)
:pack-me
:method-count-assert 9
:size-assert #x18
:flag-assert #x900000018
)
;; definition for method 3 of type generic-tie-interp-point
;; Used lq/sq
(defmethod inspect generic-tie-interp-point ((obj generic-tie-interp-point))
(format #t "[~8x] ~A~%" obj 'generic-tie-interp-point)
(format #t "~Tdata[12] @ #x~X~%" (&-> obj x))
(format #t "~Tquad: ~D~%" (-> (the-as (pointer uint128) obj) 0))
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
(format #t "~Td0: ~D~%" (-> obj d0))
(format #t "~Tvtx0: ~D~%" (-> obj vtx0))
(format #t "~Tdx: ~D~%" (-> obj dx))
(format #t "~Tdy: ~D~%" (-> obj dy))
(format #t "~Tdz: ~D~%" (-> obj dz))
(format #t "~Tunused: ~D~%" (-> obj unused))
(format #t "~Tvtx1: ~D~%" (-> obj vtx1))
(format #t "~Tu: ~D~%" (-> obj u))
(format #t "~Tv: ~D~%" (-> obj v))
(format #t "~Ttex: ~D~%" (-> obj tex))
(format #t "~Tw: ~D~%" (-> obj w))
(format #t "~Td1: ~D~%" (-> obj d1))
obj
)
;; definition of type generic-tie-ips
(deftype generic-tie-ips (structure)
((ip generic-tie-interp-point 2 :inline :offset-assert 0)
)
:method-count-assert 9
:size-assert #x30
:flag-assert #x900000030
)
;; definition for method 3 of type generic-tie-ips
(defmethod inspect generic-tie-ips ((obj generic-tie-ips))
(format #t "[~8x] ~A~%" obj 'generic-tie-ips)
(format #t "~Tip[2] @ #x~X~%" (-> obj ip))
obj
)
;; definition of type generic-tie-header
(deftype generic-tie-header (structure)
((effect uint8 :offset-assert 0)
(interp-table-size uint8 :offset-assert 1)
(num-bps uint8 :offset-assert 2)
(num-ips uint8 :offset-assert 3)
(tint-color uint32 :offset-assert 4)
(index-table-offset uint16 :offset-assert 8)
(kick-table-offset uint16 :offset-assert 10)
(normal-table-offset uint16 :offset-assert 12)
(interp-table-offset uint16 :offset-assert 14)
(gsf-header gsf-header :inline :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type generic-tie-header
(defmethod inspect generic-tie-header ((obj generic-tie-header))
(format #t "[~8x] ~A~%" obj 'generic-tie-header)
(format #t "~Teffect: ~D~%" (-> obj effect))
(format #t "~Tinterp-table-size: ~D~%" (-> obj interp-table-size))
(format #t "~Tnum-bps: ~D~%" (-> obj num-bps))
(format #t "~Tnum-ips: ~D~%" (-> obj num-ips))
(format #t "~Ttint-color: ~D~%" (-> obj tint-color))
(format #t "~Tindex-table-offset: ~D~%" (-> obj index-table-offset))
(format #t "~Tkick-table-offset: ~D~%" (-> obj kick-table-offset))
(format #t "~Tnormal-table-offset: ~D~%" (-> obj normal-table-offset))
(format #t "~Tinterp-table-offset: ~D~%" (-> obj interp-table-offset))
(format #t "~Tgsf-header: #<gsf-header @ #x~X>~%" (-> obj gsf-header))
obj
)
;; definition of type generic-tie-matrix
(deftype generic-tie-matrix (structure)
((matrix matrix :inline :offset-assert 0)
(morph vector :inline :offset-assert 64)
(fog qword :inline :offset-assert 80)
)
:method-count-assert 9
:size-assert #x60
:flag-assert #x900000060
)
;; definition for method 3 of type generic-tie-matrix
(defmethod inspect generic-tie-matrix ((obj generic-tie-matrix))
(format #t "[~8x] ~A~%" obj 'generic-tie-matrix)
(format #t "~Tmatrix: #<matrix @ #x~X>~%" (-> obj matrix))
(format #t "~Tmorph: #<vector @ #x~X>~%" (-> obj morph))
(format #t "~Tfog: #<qword @ #x~X>~%" (-> obj fog))
obj
)
;; definition of type generic-tie-normal
(deftype generic-tie-normal (structure)
((x int8 :offset-assert 0)
(y int8 :offset-assert 1)
(z int8 :offset-assert 2)
(dummy int8 :offset-assert 3)
)
:method-count-assert 9
:size-assert #x4
:flag-assert #x900000004
)
;; definition for method 3 of type generic-tie-normal
(defmethod inspect generic-tie-normal ((obj generic-tie-normal))
(format #t "[~8x] ~A~%" obj 'generic-tie-normal)
(format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj z))
(format #t "~Tdummy: ~D~%" (-> obj dummy))
obj
)
;; definition of type generic-tie-control
(deftype generic-tie-control (structure)
((ptr-palette uint32 :offset-assert 0)
(ptr-shaders uint32 :offset-assert 4)
(ptr-runctrl generic-tie-run-control :offset-assert 8)
(ptr-verts uint32 :offset-assert 12)
(ptr-generic generic-tie-header :offset-assert 16)
(ptr-dps uint32 :offset-assert 20)
(ptr-kicks uint32 :offset-assert 24)
(ptr-normals uint32 :offset-assert 28)
(ptr-interp uint32 :offset-assert 32)
(ptr-mtxs generic-tie-matrix :offset-assert 36)
(ptr-cinds uint32 :offset-assert 40)
(next-instance uint32 :offset-assert 44)
(next-model uint32 :offset-assert 48)
(next-is-model uint32 :offset-assert 52)
(tie-type uint32 :offset-assert 56)
)
:method-count-assert 9
:size-assert #x3c
:flag-assert #x90000003c
)
;; definition for method 3 of type generic-tie-control
(defmethod inspect generic-tie-control ((obj generic-tie-control))
(format #t "[~8x] ~A~%" obj 'generic-tie-control)
(format #t "~Tptr-palette: #x~X~%" (-> obj ptr-palette))
(format #t "~Tptr-shaders: #x~X~%" (-> obj ptr-shaders))
(format
#t
"~Tptr-runctrl: #<generic-tie-run-control @ #x~X>~%"
(-> obj ptr-runctrl)
)
(format #t "~Tptr-verts: #x~X~%" (-> obj ptr-verts))
(format
#t
"~Tptr-generic: #<generic-tie-header @ #x~X>~%"
(-> obj ptr-generic)
)
(format #t "~Tptr-dps: #x~X~%" (-> obj ptr-dps))
(format #t "~Tptr-kicks: #x~X~%" (-> obj ptr-kicks))
(format #t "~Tptr-normals: #x~X~%" (-> obj ptr-normals))
(format #t "~Tptr-interp: #x~X~%" (-> obj ptr-interp))
(format #t "~Tptr-mtxs: #<generic-tie-matrix @ #x~X>~%" (-> obj ptr-mtxs))
(format #t "~Tptr-cinds: #x~X~%" (-> obj ptr-cinds))
(format #t "~Tnext-instance: #x~X~%" (-> obj next-instance))
(format #t "~Tnext-model: #x~X~%" (-> obj next-model))
(format #t "~Tnext-is-model: ~D~%" (-> obj next-is-model))
(format #t "~Ttie-type: ~D~%" (-> obj tie-type))
obj
)
;; definition of type generic-tie-stats
(deftype generic-tie-stats (structure)
((num-bps uint32 :offset-assert 0)
(num-ips uint32 :offset-assert 4)
(num-dps uint32 :offset-assert 8)
(num-shaders uint32 :offset-assert 12)
(num-models uint32 :offset-assert 16)
(num-instances uint32 :offset-assert 20)
(num-waits uint32 :offset-assert 24)
(num-qwc uint32 :offset-assert 28)
(max-qwc uint32 :offset-assert 32)
)
:method-count-assert 9
:size-assert #x24
:flag-assert #x900000024
)
;; definition for method 3 of type generic-tie-stats
(defmethod inspect generic-tie-stats ((obj generic-tie-stats))
(format #t "[~8x] ~A~%" obj 'generic-tie-stats)
(format #t "~Tnum-bps: ~D~%" (-> obj num-bps))
(format #t "~Tnum-ips: ~D~%" (-> obj num-ips))
(format #t "~Tnum-dps: ~D~%" (-> obj num-dps))
(format #t "~Tnum-shaders: ~D~%" (-> obj num-shaders))
(format #t "~Tnum-models: ~D~%" (-> obj num-models))
(format #t "~Tnum-instances: ~D~%" (-> obj num-instances))
(format #t "~Tnum-waits: ~D~%" (-> obj num-waits))
(format #t "~Tnum-qwc: ~D~%" (-> obj num-qwc))
(format #t "~Tmax-qwc: ~D~%" (-> obj max-qwc))
obj
)
;; definition of type generic-tie-calls
(deftype generic-tie-calls (structure)
((generic-prepare-dma-double basic :offset-assert 0)
(generic-envmap-dproc basic :offset-assert 4)
(generic-interp-dproc basic :offset-assert 8)
(generic-no-light-dproc basic :offset-assert 12)
)
:pack-me
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type generic-tie-calls
(defmethod inspect generic-tie-calls ((obj generic-tie-calls))
(format #t "[~8x] ~A~%" obj 'generic-tie-calls)
(format
#t
"~Tgeneric-prepare-dma-double: ~A~%"
(-> obj generic-prepare-dma-double)
)
(format #t "~Tgeneric-envmap-dproc: ~A~%" (-> obj generic-envmap-dproc))
(format #t "~Tgeneric-interp-dproc: ~A~%" (-> obj generic-interp-dproc))
(format #t "~Tgeneric-no-light-dproc: ~A~%" (-> obj generic-no-light-dproc))
obj
)
;; definition of type generic-tie-shadow
(deftype generic-tie-shadow (structure)
((out-buf gsf-buffer :offset-assert 0)
(cur-buf uint32 :offset-assert 4)
(tie-type int32 :offset-assert 8)
(ptr-inst uint32 :offset-assert 12)
(ptr-buf uint32 :offset-assert 16)
(inst-xor int32 :offset-assert 20)
(end-of-chain uint32 :offset-assert 24)
(write-limit uint32 :offset-assert 28)
(calls generic-tie-calls :inline :offset-assert 32)
)
:pack-me
:method-count-assert 9
:size-assert #x30
:flag-assert #x900000030
)
;; definition for method 3 of type generic-tie-shadow
(defmethod inspect generic-tie-shadow ((obj generic-tie-shadow))
(format #t "[~8x] ~A~%" obj 'generic-tie-shadow)
(format #t "~Tout-buf: #<gsf-buffer @ #x~X>~%" (-> obj out-buf))
(format #t "~Tcur-buf: #x~X~%" (-> obj cur-buf))
(format #t "~Ttie-type: ~D~%" (-> obj tie-type))
(format #t "~Tptr-inst: #x~X~%" (-> obj ptr-inst))
(format #t "~Tptr-buf: #x~X~%" (-> obj ptr-buf))
(format #t "~Tinst-xor: ~D~%" (-> obj inst-xor))
(format #t "~Tend-of-chain: ~D~%" (-> obj end-of-chain))
(format #t "~Twrite-limit: ~D~%" (-> obj write-limit))
(format #t "~Tcalls: #<generic-tie-calls @ #x~X>~%" (-> obj calls))
obj
)
;; definition of type generic-tie-work
(deftype generic-tie-work (structure)
((control generic-tie-control :inline :offset-assert 0)
(interp-job generic-interp-job :inline :offset-assert 60)
(shadow generic-tie-shadow :inline :offset-assert 76)
(input-a generic-tie-input :inline :offset-assert 128)
(input-b generic-tie-input :inline :offset-assert 3376)
(inst-buf generic-tie-instance :inline :offset-assert 6624)
(palette-buf rgba 128 :offset-assert 6992)
)
:method-count-assert 9
:size-assert #x1d50
:flag-assert #x900001d50
)
;; definition for method 3 of type generic-tie-work
(defmethod inspect generic-tie-work ((obj generic-tie-work))
(format #t "[~8x] ~A~%" obj 'generic-tie-work)
(format #t "~Tcontrol: #<generic-tie-control @ #x~X>~%" (-> obj control))
(format #t "~Tinterp-job: #<generic-interp-job @ #x~X>~%" (-> obj interp-job))
(format #t "~Tshadow: #<generic-tie-shadow @ #x~X>~%" (-> obj shadow))
(format #t "~Tinput-a: #<generic-tie-input @ #x~X>~%" (-> obj input-a))
(format #t "~Tinput-b: #<generic-tie-input @ #x~X>~%" (-> obj input-b))
(format #t "~Tinst-buf: #<generic-tie-instance @ #x~X>~%" (-> obj inst-buf))
(format #t "~Tpalette-buf[128] @ #x~X~%" (-> obj palette-buf))
obj
)
;; failed to figure out what this is:
(let ((v0-15 0))
)

272
test/decompiler/reference/engine/gfx/tie/prototype-h_REF.gc Normal file
View file

@ -0,0 +1,272 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type prototype-bucket
(deftype prototype-bucket (basic)
((name basic :offset-assert 4)
(flags uint32 :offset-assert 8)
(in-level uint16 :offset-assert 12)
(utextures uint16 :offset-assert 14)
(geometry uint32 4 :offset-assert 16)
(dists vector :inline :offset-assert 32)
(rdists vector :inline :offset-assert 48)
(next uint32 4 :offset-assert 64)
(count uint16 4 :offset-assert 80)
(near-plane float :offset 32)
(near-stiff float :offset 36)
(mid-plane float :offset 40)
(far-plane float :offset 44)
(rlength-near float :offset 48)
(rlength-stiff float :offset 52)
(rlength-mid float :offset 56)
(stiffness float :offset 60)
(next-clear uint128 :offset 64)
(count-clear uint64 :offset 80)
)
:method-count-assert 9
:size-assert #x58
:flag-assert #x900000058
)
;; definition for method 3 of type prototype-bucket
;; Used lq/sq
(defmethod inspect prototype-bucket ((obj prototype-bucket))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tflags: ~D~%" (-> obj flags))
(format #t "~Tin-level: ~D~%" (-> obj in-level))
(format #t "~Tutextures: ~D~%" (-> obj utextures))
(format #t "~Tgeometry[4] @ #x~X~%" (-> obj geometry))
(format #t "~Tdists: #<vector @ #x~X>~%" (-> obj dists))
(format #t "~Trdists: #<vector @ #x~X>~%" (-> obj rdists))
(format #t "~Tnext[4] @ #x~X~%" (-> obj next))
(format #t "~Tcount[4] @ #x~X~%" (-> obj count))
(format #t "~Tnear-plane: (meters ~m)~%" (-> obj dists x))
(format #t "~Tnear-stiff: (meters ~m)~%" (-> obj dists y))
(format #t "~Tmid-plane: (meters ~m)~%" (-> obj dists z))
(format #t "~Tfar-plane: (meters ~m)~%" (-> obj dists w))
(format #t "~Trlength-near: ~f~%" (-> obj rdists x))
(format #t "~Trlength-stiff: ~f~%" (-> obj rdists y))
(format #t "~Trlength-mid: ~f~%" (-> obj rdists z))
(format #t "~Tstiffness: ~f~%" (-> obj rdists w))
(format #t "~Tnext-clear: ~D~%" (-> obj next-clear))
(format #t "~Tcount-clear: ~D~%" (-> obj count-clear))
obj
)
;; definition of type prototype-bucket-shrub
(deftype prototype-bucket-shrub (prototype-bucket)
((mod-count uint16 4 :offset-assert 88)
(last uint32 4 :offset-assert 96)
(last-clear uint128 :offset 96)
)
:method-count-assert 9
:size-assert #x70
:flag-assert #x900000070
)
;; definition for method 3 of type prototype-bucket-shrub
;; Used lq/sq
(defmethod inspect prototype-bucket-shrub ((obj prototype-bucket-shrub))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tflags: ~D~%" (-> obj flags))
(format #t "~Tin-level: ~D~%" (-> obj in-level))
(format #t "~Tutextures: ~D~%" (-> obj utextures))
(format #t "~Tgeometry[4] @ #x~X~%" (-> obj geometry))
(format #t "~Tdists: #<vector @ #x~X>~%" (-> obj dists))
(format #t "~Trdists: #<vector @ #x~X>~%" (-> obj rdists))
(format #t "~Tnext[4] @ #x~X~%" (-> obj next))
(format #t "~Tcount[4] @ #x~X~%" (-> obj count))
(format #t "~Tnear-plane: (meters ~m)~%" (-> obj dists x))
(format #t "~Tnear-stiff: (meters ~m)~%" (-> obj dists y))
(format #t "~Tmid-plane: (meters ~m)~%" (-> obj dists z))
(format #t "~Tfar-plane: (meters ~m)~%" (-> obj dists w))
(format #t "~Trlength-near: ~f~%" (-> obj rdists x))
(format #t "~Trlength-stiff: ~f~%" (-> obj rdists y))
(format #t "~Trlength-mid: ~f~%" (-> obj rdists z))
(format #t "~Tstiffness: ~f~%" (-> obj rdists w))
(format #t "~Tnext-clear: ~D~%" (-> obj next-clear))
(format #t "~Tcount-clear: ~D~%" (-> obj count-clear))
(format #t "~Tmod-count[4] @ #x~X~%" (-> obj mod-count))
(format #t "~Tlast[4] @ #x~X~%" (-> obj last))
(format #t "~Tlast-clear: ~D~%" (-> obj last-clear))
obj
)
;; definition of type prototype-inline-array-shrub
(deftype prototype-inline-array-shrub (drawable)
((length int16 :offset 6)
(data prototype-bucket-shrub 1 :inline :offset 32)
(_pad uint32 :offset-assert 144)
)
:method-count-assert 18
:size-assert #x94
:flag-assert #x1200000094
)
;; definition for method 3 of type prototype-inline-array-shrub
(defmethod
inspect
prototype-inline-array-shrub
((obj prototype-inline-array-shrub))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tid: ~D~%" (-> obj id))
(format #t "~Tbsphere: ~`vector`P~%" (-> obj bsphere))
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Tdata[1] @ #x~X~%" (-> obj data))
obj
)
;; definition of type prototype-array-shrub-info
(deftype prototype-array-shrub-info (basic)
((prototype-inline-array-shrub basic :offset-assert 4)
(wind-vectors uint32 :offset-assert 8)
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type prototype-array-shrub-info
(defmethod inspect prototype-array-shrub-info ((obj prototype-array-shrub-info))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format
#t
"~Tprototype-inline-array-shrub: ~A~%"
(-> obj prototype-inline-array-shrub)
)
(format #t "~Twind-vectors: #x~X~%" (-> obj wind-vectors))
obj
)
;; definition of type prototype-bucket-tie
(deftype prototype-bucket-tie (prototype-bucket)
((generic-count uint16 4 :offset-assert 88)
(generic-next uint32 4 :offset-assert 96)
(frag-count uint8 4 :offset-assert 112)
(index-start uint8 4 :offset-assert 116)
(base-qw uint16 4 :offset-assert 120)
(envmap-rfade float :offset-assert 128)
(envmap-fade-far float :offset-assert 132)
(envmap-shader adgif-shader :offset-assert 136)
(collide-frag basic :offset-assert 140)
(tie-colors basic :offset-assert 144)
(data uint32 :dynamic :offset-assert 148)
(color-index-qwc uint32 :dynamic :offset-assert 148)
(generic-next-clear uint128 :offset 96)
(generic-count-clear uint128 :offset 80)
)
:method-count-assert 9
:size-assert #x94
:flag-assert #x900000094
)
;; definition for method 3 of type prototype-bucket-tie
;; Used lq/sq
(defmethod inspect prototype-bucket-tie ((obj prototype-bucket-tie))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tname: ~A~%" (-> obj name))
(format #t "~Tflags: ~D~%" (-> obj flags))
(format #t "~Tin-level: ~D~%" (-> obj in-level))
(format #t "~Tutextures: ~D~%" (-> obj utextures))
(format #t "~Tgeometry[4] @ #x~X~%" (-> obj geometry))
(format #t "~Tdists: #<vector @ #x~X>~%" (-> obj dists))
(format #t "~Trdists: #<vector @ #x~X>~%" (-> obj rdists))
(format #t "~Tnext[4] @ #x~X~%" (-> obj next))
(format #t "~Tcount[4] @ #x~X~%" (-> obj count))
(format #t "~Tnear-plane: (meters ~m)~%" (-> obj dists x))
(format #t "~Tnear-stiff: (meters ~m)~%" (-> obj dists y))
(format #t "~Tmid-plane: (meters ~m)~%" (-> obj dists z))
(format #t "~Tfar-plane: (meters ~m)~%" (-> obj dists w))
(format #t "~Trlength-near: ~f~%" (-> obj rdists x))
(format #t "~Trlength-stiff: ~f~%" (-> obj rdists y))
(format #t "~Trlength-mid: ~f~%" (-> obj rdists z))
(format #t "~Tstiffness: ~f~%" (-> obj rdists w))
(format #t "~Tnext-clear: ~D~%" (-> obj next-clear))
(format #t "~Tcount-clear: ~D~%" (-> obj count-clear))
(format #t "~Tgeneric-count[4] @ #x~X~%" (-> obj generic-count))
(format #t "~Tgeneric-next[4] @ #x~X~%" (-> obj generic-next))
(format #t "~Tfrag-count[4] @ #x~X~%" (-> obj frag-count))
(format #t "~Tindex-start[4] @ #x~X~%" (-> obj index-start))
(format #t "~Tbase-qw[4] @ #x~X~%" (-> obj base-qw))
(format #t "~Tenvmap-rfade: ~f~%" (-> obj envmap-rfade))
(format #t "~Tenvmap-fade-far: ~f~%" (-> obj envmap-fade-far))
(format #t "~Tenvmap-shader: #<adgif-shader @ #x~X>~%" (-> obj envmap-shader))
(format #t "~Tcollide-frag: ~A~%" (-> obj collide-frag))
(format #t "~Ttie-colors: ~A~%" (-> obj tie-colors))
(format #t "~Tdata[0] @ #x~X~%" (-> obj data))
(format #t "~Tcolor-index-qwc[0] @ #x~X~%" (-> obj data))
(format #t "~Tgeneric-next-clear: ~D~%" (-> obj generic-next-clear))
(format #t "~Tgeneric-count-clear: ~D~%" (-> obj generic-count-clear))
obj
)
;; definition of type prototype-array-tie
(deftype prototype-array-tie (array)
()
:method-count-assert 10
:size-assert #x10
:flag-assert #xa00000010
(:methods
(dummy-9 () none 9)
)
)
;; definition for method 3 of type prototype-array-tie
(defmethod inspect prototype-array-tie ((obj prototype-array-tie))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Ttype: ~A~%" (-> obj type))
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Tallocated-length: ~D~%" (-> obj allocated-length))
(format #t "~Tcontent-type: ~A~%" (-> obj content-type))
obj
)
;; definition of type proxy-prototype-array-tie
(deftype proxy-prototype-array-tie (basic)
((prototype-array-tie basic :offset-assert 4)
(wind-vectors uint32 :offset-assert 8)
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type proxy-prototype-array-tie
(defmethod inspect proxy-prototype-array-tie ((obj proxy-prototype-array-tie))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tprototype-array-tie: ~A~%" (-> obj prototype-array-tie))
(format #t "~Twind-vectors: #x~X~%" (-> obj wind-vectors))
obj
)
;; definition of type instance
(deftype instance (drawable)
((bucket-index uint16 :offset 6)
(origin matrix4h :inline :offset-assert 32)
(wind-index uint16 :offset 62)
)
:method-count-assert 18
:size-assert #x40
:flag-assert #x1200000040
)
;; definition for method 3 of type instance
(defmethod inspect instance ((obj instance))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tid: ~D~%" (-> obj id))
(format #t "~Tbsphere: ~`vector`P~%" (-> obj bsphere))
(format #t "~Tbucket-index: ~D~%" (-> obj bucket-index))
(format #t "~Torigin: #<matrix4h @ #x~X>~%" (-> obj origin))
(format #t "~Twind-index: ~D~%" (-> obj wind-index))
obj
)
;; failed to figure out what this is:
(let ((v0-8 0))
)

226
test/decompiler/reference/engine/gfx/time-of-day-h_REF.gc Normal file
View file

@ -0,0 +1,226 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type palette-fade-control
(deftype palette-fade-control (structure)
((trans vector :inline :offset-assert 0)
(fade float :offset-assert 16)
(actor-dist float :offset-assert 20)
)
:method-count-assert 9
:size-assert #x18
:flag-assert #x900000018
)
;; definition for method 3 of type palette-fade-control
(defmethod inspect palette-fade-control ((obj palette-fade-control))
(format #t "[~8x] ~A~%" obj 'palette-fade-control)
(format #t "~Ttrans: #<vector @ #x~X>~%" (-> obj trans))
(format #t "~Tfade: ~f~%" (-> obj fade))
(format #t "~Tactor-dist: ~f~%" (-> obj actor-dist))
obj
)
;; definition of type palette-fade-controls
(deftype palette-fade-controls (basic)
((control palette-fade-control 8 :inline :offset-assert 16)
)
:method-count-assert 11
:size-assert #x110
:flag-assert #xb00000110
(:methods
(dummy-9 () none 9)
(dummy-10 () none 10)
)
)
;; definition for method 3 of type palette-fade-controls
(defmethod inspect palette-fade-controls ((obj palette-fade-controls))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tcontrol[8] @ #x~X~%" (-> obj control))
obj
)
;; definition (perm) for symbol *palette-fade-controls*, type palette-fade-controls
(define-perm *palette-fade-controls* palette-fade-controls
(new 'global 'palette-fade-controls)
)
;; definition of type time-of-day-proc
(deftype time-of-day-proc (process)
((year int32 :offset-assert 112)
(month int32 :offset-assert 116)
(week int32 :offset-assert 120)
(day int32 :offset-assert 124)
(hour int32 :offset-assert 128)
(minute int32 :offset-assert 132)
(second int32 :offset-assert 136)
(frame int32 :offset-assert 140)
(time-of-day float :offset-assert 144)
(time-ratio float :offset-assert 148)
(star-count int32 :offset-assert 152)
(stars basic :offset-assert 156)
(sun-count int32 :offset-assert 160)
(sun basic :offset-assert 164)
(green-sun-count int32 :offset-assert 168)
(green-sun basic :offset-assert 172)
(moon-count int32 :offset-assert 176)
(moon basic :offset-assert 180)
)
:heap-base #x50
:method-count-assert 14
:size-assert #xb8
:flag-assert #xe005000b8
)
;; definition for method 3 of type time-of-day-proc
(defmethod inspect time-of-day-proc ((obj time-of-day-proc))
(let ((t9-0 (method-of-type process inspect)))
(t9-0 obj)
)
(format #t "~T~Tyear: ~D~%" (-> obj year))
(format #t "~T~Tmonth: ~D~%" (-> obj month))
(format #t "~T~Tweek: ~D~%" (-> obj week))
(format #t "~T~Tday: ~D~%" (-> obj day))
(format #t "~T~Thour: ~D~%" (-> obj hour))
(format #t "~T~Tminute: ~D~%" (-> obj minute))
(format #t "~T~Tsecond: ~D~%" (-> obj second))
(format #t "~T~Tframe: ~D~%" (-> obj frame))
(format #t "~T~Ttime-of-day: ~f~%" (-> obj time-of-day))
(format #t "~T~Ttime-ratio: ~f~%" (-> obj time-ratio))
(format #t "~T~Tstar-count: ~D~%" (-> obj star-count))
(format #t "~T~Tstars: ~A~%" (-> obj stars))
(format #t "~T~Tsun-count: ~D~%" (-> obj sun-count))
(format #t "~T~Tsun: ~A~%" (-> obj sun))
(format #t "~T~Tgreen-sun-count: ~D~%" (-> obj green-sun-count))
(format #t "~T~Tgreen-sun: ~A~%" (-> obj green-sun))
(format #t "~T~Tmoon-count: ~D~%" (-> obj moon-count))
(format #t "~T~Tmoon: ~A~%" (-> obj moon))
obj
)
;; definition of type time-of-day-palette
(deftype time-of-day-palette (basic)
((width int32 :offset-assert 4)
(height int32 :offset-assert 8)
(pad int32 :offset-assert 12)
(data int32 1 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x14
:flag-assert #x900000014
)
;; definition for method 3 of type time-of-day-palette
(defmethod inspect time-of-day-palette ((obj time-of-day-palette))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Twidth: ~D~%" (-> obj width))
(format #t "~Theight: ~D~%" (-> obj height))
(format #t "~Tpad: ~D~%" (-> obj pad))
(format #t "~Tdata[1] @ #x~X~%" (-> obj data))
obj
)
;; definition of type time-of-day-context
(deftype time-of-day-context (basic)
((active-count uint32 :offset-assert 4)
(interp float :offset-assert 8)
(current-interp float :offset-assert 12)
(moods uint64 2 :offset-assert 16)
(current-fog mood-fog :inline :offset-assert 32)
(current-sun mood-sun :inline :offset-assert 80)
(current-prt-color vector :inline :offset-assert 112)
(current-shadow vector :inline :offset-assert 128)
(current-shadow-color vector :inline :offset-assert 144)
(light-group light-group 9 :inline :offset-assert 160)
(title-light-group light-group :inline :offset-assert 1888)
(time float :offset-assert 2080)
(target-interp float :offset-assert 2084)
(erase-color uint32 :offset-assert 2088)
(num-stars float :offset-assert 2092)
(light-masks-0 uint8 2 :offset-assert 2096)
(light-masks-1 uint8 2 :offset-assert 2098)
(light-interp uint32 2 :offset-assert 2100)
(sky basic :offset-assert 2108)
(sun-fade float :offset-assert 2112)
(title-updated symbol :offset-assert 2116)
)
:method-count-assert 9
:size-assert #x848
:flag-assert #x900000848
)
;; definition for method 3 of type time-of-day-context
(defmethod inspect time-of-day-context ((obj time-of-day-context))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tactive-count: ~D~%" (-> obj active-count))
(format #t "~Tinterp: ~f~%" (-> obj interp))
(format #t "~Tcurrent-interp: ~f~%" (-> obj current-interp))
(format #t "~Tmoods[2] @ #x~X~%" (-> obj moods))
(format #t "~Tcurrent-fog: #<mood-fog @ #x~X>~%" (-> obj current-fog))
(format #t "~Tcurrent-sun: #<mood-sun @ #x~X>~%" (-> obj current-sun))
(format
#t
"~Tcurrent-prt-color: #<vector @ #x~X>~%"
(-> obj current-prt-color)
)
(format #t "~Tcurrent-shadow: #<vector @ #x~X>~%" (-> obj current-shadow))
(format
#t
"~Tcurrent-shadow-color: #<vector @ #x~X>~%"
(-> obj current-shadow-color)
)
(format #t "~Tlight-group[9] @ #x~X~%" (-> obj light-group))
(format
#t
"~Ttitle-light-group: #<light-group @ #x~X>~%"
(-> obj title-light-group)
)
(format #t "~Ttime: ~f~%" (-> obj time))
(format #t "~Ttarget-interp: ~f~%" (-> obj target-interp))
(format #t "~Terase-color: ~D~%" (-> obj erase-color))
(format #t "~Tnum-stars: ~f~%" (-> obj num-stars))
(format #t "~Tlight-masks-0[2] @ #x~X~%" (-> obj light-masks-0))
(format #t "~Tlight-masks-1[2] @ #x~X~%" (-> obj light-masks-1))
(format #t "~Tlight-interp[2] @ #x~X~%" (-> obj light-interp))
(format #t "~Tsky: ~A~%" (-> obj sky))
(format #t "~Tsun-fade: ~f~%" (-> obj sun-fade))
(format #t "~Ttitle-updated: ~A~%" (-> obj title-updated))
obj
)
;; definition of type time-of-day-dma
(deftype time-of-day-dma (structure)
((outa uint32 256 :offset-assert 0)
(outb uint32 256 :offset-assert 1024)
(banka uint32 256 :offset-assert 2048)
(bankb uint32 256 :offset-assert 3072)
)
:method-count-assert 9
:size-assert #x1000
:flag-assert #x900001000
)
;; definition for method 3 of type time-of-day-dma
(defmethod inspect time-of-day-dma ((obj time-of-day-dma))
(format #t "[~8x] ~A~%" obj 'time-of-day-dma)
(format #t "~Touta[256] @ #x~X~%" (-> obj outa))
(format #t "~Toutb[256] @ #x~X~%" (-> obj outb))
(format #t "~Tbanka[256] @ #x~X~%" (-> obj banka))
(format #t "~Tbankb[256] @ #x~X~%" (-> obj bankb))
obj
)
;; definition for symbol *time-of-day-mode*, type int
(define *time-of-day-mode* 8)
;; definition for symbol *time-of-day-context*, type time-of-day-context
(define *time-of-day-context* (new 'static 'time-of-day-context))
;; failed to figure out what this is:
(let ((v0-7 0))
)

461
test/decompiler/reference/engine/load/load-dgo_REF.gc Normal file
View file

@ -0,0 +1,461 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type load-dgo-msg
(deftype load-dgo-msg (structure)
((rsvd uint16 :offset-assert 0)
(result load-msg-result :offset-assert 2)
(b1 uint32 :offset-assert 4)
(b2 uint32 :offset-assert 8)
(bt uint32 :offset-assert 12)
(name uint128 :offset-assert 16)
(name-chars uint8 16 :offset 16)
(address uint32 :offset 4)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type load-dgo-msg
;; Used lq/sq
(defmethod inspect load-dgo-msg ((obj load-dgo-msg))
(format #t "[~8x] ~A~%" obj 'load-dgo-msg)
(format #t "~Trsvd: ~D~%" (-> obj rsvd))
(format #t "~Tresult: ~D~%" (-> obj result))
(format #t "~Tb1: #x~X~%" (-> obj b1))
(format #t "~Tb2: #x~X~%" (-> obj b2))
(format #t "~Tbt: #x~X~%" (-> obj bt))
(format #t "~Tname: ~D~%" (-> obj name))
(format #t "~Taddress: ~D~%" (-> obj b1))
obj
)
;; definition of type load-chunk-msg
(deftype load-chunk-msg (structure)
((rsvd uint16 :offset-assert 0)
(result load-msg-result :offset-assert 2)
(address pointer :offset-assert 4)
(section uint32 :offset-assert 8)
(maxlen uint32 :offset-assert 12)
(id uint32 :offset 4)
(basename uint8 48 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x40
:flag-assert #x900000040
)
;; definition for method 3 of type load-chunk-msg
(defmethod inspect load-chunk-msg ((obj load-chunk-msg))
(format #t "[~8x] ~A~%" obj 'load-chunk-msg)
(format #t "~Trsvd: ~D~%" (-> obj rsvd))
(format #t "~Tresult: ~D~%" (-> obj result))
(format #t "~Taddress: ~D~%" (-> obj address))
(format #t "~Tsection: ~D~%" (-> obj section))
(format #t "~Tmaxlen: ~D~%" (-> obj maxlen))
(format #t "~Tid: ~D~%" (-> obj address))
(format #t "~Tbasename[48] @ #x~X~%" (-> obj basename))
obj
)
;; definition of type dgo-header
(deftype dgo-header (structure)
((length uint32 :offset-assert 0)
(rootname uint8 60 :offset-assert 4)
(data uint8 :dynamic :offset-assert 64)
)
:method-count-assert 9
:size-assert #x40
:flag-assert #x900000040
)
;; definition for method 3 of type dgo-header
(defmethod inspect dgo-header ((obj dgo-header))
(format #t "[~8x] ~A~%" obj 'dgo-header)
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Trootname[60] @ #x~X~%" (-> obj rootname))
obj
)
;; failed to figure out what this is:
(when (zero? *load-dgo-rpc*)
(set!
*load-dgo-rpc*
(new 'global 'rpc-buffer-pair (the-as uint 32) (the-as uint 1) 3)
)
(set!
*load-str-rpc*
(new 'global 'rpc-buffer-pair (the-as uint 64) (the-as uint 1) 4)
)
(set!
*play-str-rpc*
(new 'global 'rpc-buffer-pair (the-as uint 64) (the-as uint 2) 5)
)
(set! *load-str-lock* #f)
(set! *que-str-lock* #f)
(set! *dgo-name* (new 'global 'string 64 (the-as string #f)))
)
;; definition for function str-load
(defun str-load ((name string) (chunk-id int) (address pointer) (len int))
(if (or (check-busy *load-str-rpc*) *load-str-lock*)
(return #f)
)
(let ((cmd (the-as load-chunk-msg (add-element *load-str-rpc*))))
(set! (-> cmd result) (load-msg-result invalid))
(set! (-> cmd address) address)
(set! (-> cmd section) (the-as uint chunk-id))
(set! (-> cmd maxlen) (the-as uint len))
(charp<-string (-> cmd basename) name)
(call *load-str-rpc* (the-as uint 0) (the-as pointer cmd) (the-as uint 32))
)
(set! *load-str-lock* #t)
(set! *que-str-lock* #t)
#t
)
;; definition for function str-load-status
;; INFO: Return type mismatch structure vs symbol.
(defun str-load-status ((length-out (pointer int32)))
(if (check-busy *load-str-rpc*)
(return 'busy)
)
(set! *load-str-lock* #f)
(set! *que-str-lock* #t)
(let ((response (the-as load-chunk-msg (pop-last-received *load-str-rpc*))))
(if (= (-> response result) (load-msg-result error))
(return 'error)
)
(set!
(-> length-out 0)
(the-as int (the-as load-chunk-msg (-> response maxlen)))
)
)
(the-as symbol 'complete)
)
;; definition for function str-load-cancel
;; INFO: Return type mismatch int vs none.
(defun str-load-cancel ()
(set! *load-str-lock* #f)
(set! *que-str-lock* #t)
(let ((v0-0 0))
)
(none)
)
;; definition for function str-play-async
;; INFO: Return type mismatch int vs none.
(defun str-play-async ((name string) (addr pointer))
(set! *que-str-lock* #t)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(charp<-string (-> cmd basename) name)
(set! (-> cmd address) addr)
(set! (-> cmd result) (load-msg-result done))
)
(let ((v1-2 0))
)
(let ((v0-2 0))
)
(none)
)
;; definition for function str-play-stop
;; INFO: Return type mismatch int vs none.
(defun str-play-stop ((name string))
(set! *que-str-lock* #t)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(charp<-string (-> cmd basename) name)
(set! (-> cmd result) (load-msg-result error))
)
(let ((v0-2 0))
)
(none)
)
;; definition for function str-play-queue
;; INFO: Return type mismatch int vs none.
(defun str-play-queue ((name string))
(when
(and
(not (check-busy *play-str-rpc*))
(not *load-str-lock*)
(not *que-str-lock*)
)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(charp<-string (-> cmd basename) name)
(set! (-> cmd result) (load-msg-result more))
)
)
(set! *que-str-lock* #f)
(let ((v0-3 0))
)
(none)
)
;; definition for function str-ambient-play
;; INFO: Return type mismatch int vs none.
(defun str-ambient-play ((name string))
(set! *que-str-lock* #t)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(set! (-> cmd basename 0) (the-as uint 36))
(charp<-string (&-> cmd basename 1) name)
(set! (-> cmd result) (load-msg-result done))
)
(let ((v1-3 0))
)
(let ((v0-2 0))
)
(none)
)
;; definition for function str-ambient-stop
;; INFO: Return type mismatch int vs none.
(defun str-ambient-stop ((name string))
(set! *que-str-lock* #t)
(let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*))))
(set! (-> cmd basename 0) (the-as uint 36))
(charp<-string (&-> cmd basename 1) name)
(set! (-> cmd result) (load-msg-result error))
)
(let ((v0-2 0))
)
(none)
)
;; definition for function str-play-kick
;; INFO: Return type mismatch int vs none.
(defun str-play-kick ()
(cond
((check-busy *play-str-rpc*)
)
(else
(call *play-str-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
)
)
(let ((v0-2 0))
)
(none)
)
;; definition for symbol *dgo-time*, type uint
(define *dgo-time* (the-as uint 0))
;; definition for function dgo-load-begin
;; Used lq/sq
(defun
dgo-load-begin
((name string) (buffer1 int) (buffer2 int) (current-heap int))
(set! *dgo-time* (-> *display* real-integral-frame-counter))
(format 0 "Starting level load clock~%")
(sync *load-dgo-rpc* #t)
(let ((cmd (the-as load-dgo-msg (add-element *load-dgo-rpc*))))
(set! (-> cmd result) (load-msg-result invalid))
(set! (-> cmd b1) (the-as uint buffer1))
(set! (-> cmd b2) (the-as uint buffer2))
(set! (-> cmd bt) (the-as uint current-heap))
(set! (-> cmd name) (string->sound-name name))
(call *load-dgo-rpc* (the-as uint 0) (the-as pointer cmd) (the-as uint 32))
cmd
)
)
;; definition for function dgo-load-get-next
;; INFO: Return type mismatch uint vs pointer.
(defun dgo-load-get-next ((last-object (pointer symbol)))
(set! (-> last-object 0) #t)
(let ((load-location (the-as pointer #f)))
(when (not (check-busy *load-dgo-rpc*))
(let ((response (the-as load-dgo-msg (pop-last-received *load-dgo-rpc*))))
(when response
(if
(or
(= (-> response result) (load-msg-result done))
(= (-> response result) (load-msg-result more))
)
(set! load-location (the-as pointer (-> response b1)))
)
(if (= (-> response result) (load-msg-result more))
(set! (-> last-object 0) #f)
)
(if (= (-> response result) (load-msg-result done))
(format
0
"Elapsed time for level = ~Fs~%"
(*
0.016666668
(the float (- (-> *display* real-integral-frame-counter) *dgo-time*))
)
)
)
)
)
)
(the-as pointer (the-as uint load-location))
)
)
;; definition for function dgo-load-continue
;; INFO: Return type mismatch load-dgo-msg vs int.
;; Used lq/sq
(defun dgo-load-continue ((current-heap pointer))
(let ((cmd (the-as load-dgo-msg (add-element *load-dgo-rpc*))))
(set! (-> cmd result) (load-msg-result invalid))
(set! (-> cmd b1) (the-as uint 0))
(set! (-> cmd b2) (the-as uint 0))
(set! (-> cmd bt) (the-as uint current-heap))
(set! (-> cmd name) (the-as uint128 0))
(call *load-dgo-rpc* (the-as uint 1) (the-as pointer cmd) (the-as uint 32))
(the-as int cmd)
)
)
;; definition for function dgo-load-cancel
;; INFO: Return type mismatch int vs none.
(defun dgo-load-cancel ()
(sync *load-dgo-rpc* #t)
(let ((cmd (add-element *load-dgo-rpc*)))
(call *load-dgo-rpc* (the-as uint 2) cmd (the-as uint 32))
)
(let ((v0-3 0))
)
(none)
)
;; definition for function find-temp-buffer
;; INFO: Return type mismatch int vs pointer.
(defun find-temp-buffer ((size int))
(let ((qwc (+ (/ size 16) 2)))
(the-as pointer (cond
((<
(the-as uint qwc)
(the-as
uint
(dma-buffer-free
(->
*display*
frames
(-> *display* on-screen)
frame
global-buf
)
)
)
)
(logand
-16
(the-as
int
(&+
(->
*display*
frames
(-> *display* on-screen)
frame
global-buf
base
)
15
)
)
)
)
((<
(the-as uint qwc)
(the-as
uint
(dma-buffer-free
(->
*display*
frames
(-> *display* on-screen)
frame
global-buf
)
)
)
)
(logand
-16
(the-as
int
(&+
(->
*display*
frames
(-> *display* on-screen)
frame
global-buf
base
)
15
)
)
)
)
)
)
)
)
;; definition for function dgo-load-link
(defun
dgo-load-link
((obj-file dgo-header) (heap kheap) (print-login symbol) (last-object symbol))
(let ((obj-data (-> obj-file data)))
(if
(>=
(the-as int (&+ obj-data (-> obj-file length)))
(the-as int (-> heap top-base))
)
(format
0
"ERROR: -----> dgo file header #x~X has overrun heap #x~X by ~D bytes. This is very bad!~%"
obj-file
heap
(&- (&+ obj-data (-> obj-file length)) (the-as uint (-> heap top-base)))
)
)
(if last-object
(format
0
"NOTICE: loaded ~g, ~D bytes (~f K) at top ~D~%"
(-> obj-file rootname)
(-> obj-file length)
(* 0.0009765625 (the float (-> obj-file length)))
(&- (&+ obj-data (-> obj-file length)) (the-as uint (-> heap base)))
)
)
(string<-charp (clear *dgo-name*) (-> obj-file rootname))
(nonzero?
(link-begin
obj-data
(-> *dgo-name* data)
(the-as int (-> obj-file length))
heap
(the-as link-flag (if print-login
47
39
)
)
)
)
)
)
;; definition for function destroy-mem
;; INFO: Return type mismatch int vs none.
(defun destroy-mem ((arg0 (pointer uint32)) (arg1 (pointer uint32)))
(while (< (the-as int arg0) (the-as int arg1))
(set! (-> arg0 0) #xffffffff)
(set! arg0 (&-> arg0 1))
)
(let ((v0-0 0))
)
(none)
)

109
test/decompiler/reference/engine/load/ramdisk_REF.gc Normal file
View file

@ -0,0 +1,109 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type ramdisk-rpc-fill
(deftype ramdisk-rpc-fill (structure)
((rsvd1 int32 :offset-assert 0)
(ee-id int32 :offset-assert 4)
(rsvd2 int32 2 :offset-assert 8)
(filename uint128 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type ramdisk-rpc-fill
;; Used lq/sq
(defmethod inspect ramdisk-rpc-fill ((obj ramdisk-rpc-fill))
(format #t "[~8x] ~A~%" obj 'ramdisk-rpc-fill)
(format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
(format #t "~Tee-id: ~D~%" (-> obj ee-id))
(format #t "~Trsvd2[2] @ #x~X~%" (-> obj rsvd2))
(format #t "~Tfilename: ~D~%" (-> obj filename))
obj
)
;; definition of type ramdisk-rpc-load
(deftype ramdisk-rpc-load (structure)
((rsvd int32 :offset-assert 0)
(ee-id int32 :offset-assert 4)
(offset uint32 :offset-assert 8)
(length uint32 :offset-assert 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type ramdisk-rpc-load
(defmethod inspect ramdisk-rpc-load ((obj ramdisk-rpc-load))
(format #t "[~8x] ~A~%" obj 'ramdisk-rpc-load)
(format #t "~Trsvd: ~D~%" (-> obj rsvd))
(format #t "~Tee-id: ~D~%" (-> obj ee-id))
(format #t "~Toffset: ~D~%" (-> obj offset))
(format #t "~Tlength: ~D~%" (-> obj length))
obj
)
;; definition of type ramdisk-rpc-load-to-ee
(deftype ramdisk-rpc-load-to-ee (structure)
((rsvd int32 :offset-assert 0)
(addr int32 :offset-assert 4)
(offset int32 :offset-assert 8)
(length int32 :offset-assert 12)
(filename uint128 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type ramdisk-rpc-load-to-ee
;; Used lq/sq
(defmethod inspect ramdisk-rpc-load-to-ee ((obj ramdisk-rpc-load-to-ee))
(format #t "[~8x] ~A~%" obj 'ramdisk-rpc-load-to-ee)
(format #t "~Trsvd: ~D~%" (-> obj rsvd))
(format #t "~Taddr: ~D~%" (-> obj addr))
(format #t "~Toffset: ~D~%" (-> obj offset))
(format #t "~Tlength: ~D~%" (-> obj length))
(format #t "~Tfilename: ~D~%" (-> obj filename))
obj
)
;; definition for symbol *ramdisk-rpc*, type rpc-buffer-pair
(define
*ramdisk-rpc*
(new 'global 'rpc-buffer-pair (the-as uint 32) (the-as uint 1) 2)
)
;; definition for symbol *current-ramdisk-id*, type int
(define *current-ramdisk-id* 0)
;; definition for function ramdisk-load
(defun ramdisk-load ((file-id int) (offset uint) (length uint) (buffer pointer))
(let ((cmd (the-as ramdisk-rpc-load (add-element *ramdisk-rpc*))))
(set! (-> cmd offset) offset)
(set! (-> cmd ee-id) file-id)
(set! (-> cmd length) length)
)
(call *ramdisk-rpc* (the-as uint 0) buffer length)
0
)
;; definition for function ramdisk-sync
;; INFO: Return type mismatch int vs none.
(defun ramdisk-sync ()
(sync *ramdisk-rpc* #t)
(let ((v0-1 0))
)
(none)
)
;; failed to figure out what this is:
(let ((v0-4 0))
)

164
test/decompiler/reference/engine/ps2/memcard-h_REF.gc Normal file
View file

@ -0,0 +1,164 @@
;;-*-Lisp-*-
(in-package goal)
;; type mc-handle is defined here, but it is unknown to the decompiler
;; definition of type mc-file-info
(deftype mc-file-info (structure)
((present int32 :offset-assert 0)
(blind-data float 16 :offset-assert 4)
(blind-data-int8 int8 64 :offset 4)
(level-index int32 :offset 4)
(fuel-cell-count float :offset 8)
(money-count float :offset 12)
(buzzer-count float :offset 16)
(completion-percentage float :offset 20)
(minute uint8 :offset 24)
(hour uint8 :offset 25)
(week uint8 :offset 26)
(day uint8 :offset 27)
(month uint8 :offset 28)
(year uint8 :offset 29)
)
:pack-me
:method-count-assert 9
:size-assert #x44
:flag-assert #x900000044
)
;; definition for method 3 of type mc-file-info
(defmethod inspect mc-file-info ((obj mc-file-info))
(format #t "[~8x] ~A~%" obj 'mc-file-info)
(format #t "~Tpresent: ~D~%" (-> obj present))
(format #t "~Tblind-data[16] @ #x~X~%" (-> obj blind-data))
(format #t "~Tblind-data-int8[64] @ #x~X~%" (-> obj blind-data))
(format #t "~Tlevel-index: ~D~%" (-> obj blind-data 0))
(format #t "~Tfuel-cell-count: ~f~%" (-> obj blind-data 1))
(format #t "~Tmoney-count: ~f~%" (-> obj blind-data 2))
(format #t "~Tbuzzer-count: ~f~%" (-> obj blind-data 3))
(format #t "~Tcompletion-percentage: ~f~%" (-> obj blind-data 4))
(format #t "~Tminute: #x~X~%" (-> obj minute))
(format #t "~Thour: #x~X~%" (-> obj hour))
(format #t "~Tweek: #x~X~%" (-> obj week))
(format #t "~Tday: #x~X~%" (-> obj day))
(format #t "~Tmonth: #x~X~%" (-> obj month))
(format #t "~Tyear: #x~X~%" (-> obj year))
obj
)
;; definition of type mc-slot-info
(deftype mc-slot-info (structure)
((handle int32 :offset-assert 0)
(known int32 :offset-assert 4)
(formatted int32 :offset-assert 8)
(inited int32 :offset-assert 12)
(last-file int32 :offset-assert 16)
(mem-required int32 :offset-assert 20)
(mem-actual int32 :offset-assert 24)
(file mc-file-info 4 :inline :offset-assert 28)
)
:pack-me
:method-count-assert 9
:size-assert #x12c
:flag-assert #x90000012c
)
;; definition for method 3 of type mc-slot-info
(defmethod inspect mc-slot-info ((obj mc-slot-info))
(format #t "[~8x] ~A~%" obj 'mc-slot-info)
(format #t "~Thandle: ~D~%" (-> obj handle))
(format #t "~Tknown: ~D~%" (-> obj known))
(format #t "~Tformatted: ~D~%" (-> obj formatted))
(format #t "~Tinited: ~D~%" (-> obj inited))
(format #t "~Tlast-file: ~D~%" (-> obj last-file))
(format #t "~Tmem-required: ~D~%" (-> obj mem-required))
(format #t "~Tmem-actual: ~D~%" (-> obj mem-actual))
(format #t "~Tfile[4] @ #x~X~%" (-> obj file))
obj
)
;; definition for function mc-sync
(defun mc-sync ()
(let ((v0-0 0))
(while (zero? v0-0)
(mc-run)
(set! v0-0 (mc-check-result))
)
v0-0
)
)
;; definition for function show-mc-info
;; INFO: Return type mismatch int vs none.
(defun show-mc-info ((dma-buf dma-buffer))
(let ((info (new 'stack-no-clear 'mc-slot-info)))
(dotimes (slot-idx 2)
(mc-get-slot-info slot-idx)
(cond
((zero? (-> info known))
(format (clear *temp-string*) "SLOT ~D: EXAMINING SLOT~%" slot-idx)
(let ((v1-1 *temp-string*))
)
)
((zero? (-> info handle))
(format (clear *temp-string*) "SLOT ~D: NO CARD~%" slot-idx)
(let ((v1-3 *temp-string*))
)
)
((zero? (-> info formatted))
(format
(clear *temp-string*)
"SLOT ~D: CARD [~D] : NOT FORMATTED~%"
slot-idx
(-> info handle)
)
(let ((v1-5 *temp-string*))
)
)
((zero? (-> info inited))
(format
(clear *temp-string*)
"SLOT ~D: CARD [~D] : NO FILE [~D/~D]~%"
slot-idx
(-> info handle)
(-> info mem-required)
(-> info mem-actual)
)
(let ((v1-7 *temp-string*))
)
)
(else
(format
(clear *temp-string*)
"SLOT ~D: CARD [~D] : "
slot-idx
(-> info handle)
)
(let ((v1-8 *temp-string*))
)
(format
*temp-string*
"SAVES ~D ~D ~D ~D : LAST ~D~%"
(-> info file 0 present)
(-> info file 1 present)
(-> info file 2 present)
(-> info file 3 present)
(-> info last-file)
)
)
)
(draw-string-xy *temp-string* dma-buf 32 (+ (* 12 slot-idx) 8) 3 1)
)
)
(let ((v0-12 0))
)
(none)
)
;; failed to figure out what this is:
(let ((v0-3 0))
)

252
test/decompiler/reference/engine/ps2/rpc-h_REF.gc Normal file
View file

@ -0,0 +1,252 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type rpc-buffer
(deftype rpc-buffer (basic)
((elt-size uint32 :offset-assert 4)
(elt-count uint32 :offset-assert 8)
(elt-used uint32 :offset-assert 12)
(busy basic :offset-assert 16)
(base pointer :offset-assert 20)
(data uint8 :dynamic :offset 32)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
(:methods
(new (symbol type uint uint) rpc-buffer 0)
)
)
;; definition for method 3 of type rpc-buffer
(defmethod inspect rpc-buffer ((obj rpc-buffer))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Telt-size: ~D~%" (-> obj elt-size))
(format #t "~Telt-count: ~D~%" (-> obj elt-count))
(format #t "~Telt-used: ~D~%" (-> obj elt-used))
(format #t "~Tbusy: ~A~%" (-> obj busy))
(format #t "~Tbase: ~D~%" (-> obj base))
(format #t "~Tdata[0] @ #x~X~%" (-> obj data))
obj
)
;; definition for method 0 of type rpc-buffer
(defmethod
new
rpc-buffer
((allocation symbol) (type-to-make type) (arg0 uint) (arg1 uint))
(let*
((a2-2
(+
(+ (-> type-to-make size) 63)
(the-as uint (* (the-as int arg0) (the-as int arg1)))
)
)
(v0-0 (object-new allocation type-to-make (the-as int a2-2)))
)
(set! (-> v0-0 elt-size) arg0)
(set! (-> v0-0 elt-count) arg1)
(set! (-> v0-0 elt-used) (the-as uint 0))
(set! (-> v0-0 busy) #f)
(set!
(-> v0-0 base)
(the-as pointer (logand -64 (the-as int (&-> (-> v0-0 data) 63))))
)
v0-0
)
)
;; definition of type rpc-buffer-pair
(deftype rpc-buffer-pair (basic)
((buffer rpc-buffer 2 :offset-assert 4)
(current rpc-buffer :offset-assert 12)
(last-recv-buffer pointer :offset-assert 16)
(rpc-port int32 :offset-assert 20)
)
:method-count-assert 15
:size-assert #x18
:flag-assert #xf00000018
(:methods
(new (symbol type uint uint int) rpc-buffer-pair 0)
(call (rpc-buffer-pair uint pointer uint) int 9)
(add-element (rpc-buffer-pair) pointer 10)
(decrement-elt-used (rpc-buffer-pair) int 11)
(sync (rpc-buffer-pair symbol) int 12)
(check-busy (rpc-buffer-pair) symbol 13)
(pop-last-received (rpc-buffer-pair) pointer 14)
)
)
;; definition for method 3 of type rpc-buffer-pair
(defmethod inspect rpc-buffer-pair ((obj rpc-buffer-pair))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tbuffer[2] @ #x~X~%" (-> obj buffer))
(format #t "~Tcurrent: ~A~%" (-> obj current))
(format #t "~Tlast-recv-buffer: #x~X~%" (-> obj last-recv-buffer))
(format #t "~Trpc-port: ~D~%" (-> obj rpc-port))
obj
)
;; definition for method 0 of type rpc-buffer-pair
(defmethod
new
rpc-buffer-pair
((allocation symbol) (type-to-make type) (arg0 uint) (arg1 uint) (arg2 int))
(let
((s3-0
(object-new allocation type-to-make (the-as int (-> type-to-make size)))
)
)
(set! (-> s3-0 buffer 0) (new 'global 'rpc-buffer arg0 arg1))
(set! (-> s3-0 buffer 1) (new 'global 'rpc-buffer arg0 arg1))
(set! (-> s3-0 current) (-> s3-0 buffer 0))
(set! (-> s3-0 last-recv-buffer) (the-as pointer #f))
(set! (-> s3-0 rpc-port) arg2)
s3-0
)
)
;; definition for method 12 of type rpc-buffer-pair
(defmethod sync rpc-buffer-pair ((obj rpc-buffer-pair) (arg0 symbol))
(let ((s5-0 (if (= (-> obj current) (-> obj buffer 0))
(-> obj buffer 1)
(-> obj buffer 0)
)
)
)
(when (-> s5-0 busy)
(when (nonzero? (rpc-busy? (-> obj rpc-port)))
(if arg0
(format 0 "STALL: waiting for IOP on RPC port #~D~%" (-> obj rpc-port))
)
(while (nonzero? (rpc-busy? (-> obj rpc-port)))
(nop!)
(nop!)
(nop!)
(nop!)
(nop!)
(nop!)
(nop!)
(nop!)
)
)
(set! (-> s5-0 busy) #f)
(set! (-> s5-0 elt-used) (the-as uint 0))
(let ((v1-7 0))
)
)
)
0
)
;; definition for method 13 of type rpc-buffer-pair
(defmethod check-busy rpc-buffer-pair ((obj rpc-buffer-pair))
(let ((gp-0 (if (= (-> obj current) (-> obj buffer 0))
(-> obj buffer 1)
(-> obj buffer 0)
)
)
)
(when (-> gp-0 busy)
(if (nonzero? (rpc-busy? (-> obj rpc-port)))
(return #t)
)
(set! (-> gp-0 busy) #f)
(set! (-> gp-0 elt-used) (the-as uint 0))
(let ((v1-6 0))
)
)
)
#f
)
;; definition for method 9 of type rpc-buffer-pair
(defmethod
call
rpc-buffer-pair
((obj rpc-buffer-pair) (arg0 uint) (arg1 pointer) (arg2 uint))
(when (nonzero? (-> obj current elt-used))
(let ((s2-0 (if (= (-> obj current) (-> obj buffer 0))
(-> obj buffer 1)
(-> obj buffer 0)
)
)
)
(when (-> s2-0 busy)
(when (nonzero? (rpc-busy? (-> obj rpc-port)))
(format 0 "STALL: waiting for IOP on RPC port #~D~%" (-> obj rpc-port))
(while (nonzero? (rpc-busy? (-> obj rpc-port)))
(nop!)
(nop!)
(nop!)
(nop!)
(nop!)
(nop!)
(nop!)
(nop!)
)
)
(set! (-> s2-0 busy) #f)
(set! (-> s2-0 elt-used) (the-as uint 0))
(let ((v1-8 0))
)
)
(let ((s1-0 (-> obj current)))
(rpc-call
(-> obj rpc-port)
arg0
(the-as uint 1)
(the-as uint (-> s1-0 base))
(the-as int (* (-> s1-0 elt-size) (-> s1-0 elt-used)))
(the-as uint arg1)
(the-as int arg2)
)
(set! (-> s1-0 busy) #t)
)
(set! (-> obj last-recv-buffer) arg1)
(set! (-> obj current) s2-0)
)
)
0
)
;; definition for method 14 of type rpc-buffer-pair
(defmethod pop-last-received rpc-buffer-pair ((obj rpc-buffer-pair))
(let ((v0-0 (-> obj last-recv-buffer)))
(set! (-> obj last-recv-buffer) (the-as pointer #f))
v0-0
)
)
;; definition for method 10 of type rpc-buffer-pair
(defmethod add-element rpc-buffer-pair ((obj rpc-buffer-pair))
(let ((v1-0 (-> obj current)))
(when (= (-> v1-0 elt-used) (-> v1-0 elt-count))
(if (zero? (-> obj rpc-port))
(format 0 "WARNING: too many sound commands queued~%")
)
(call obj (the-as uint 0) (the-as pointer 0) (the-as uint 0))
(set! v1-0 (-> obj current))
)
(let ((v0-2 (&+ (-> v1-0 base) (* (-> v1-0 elt-used) (-> v1-0 elt-size)))))
(set! (-> v1-0 elt-used) (+ (-> v1-0 elt-used) 1))
v0-2
)
)
)
;; definition for method 11 of type rpc-buffer-pair
(defmethod decrement-elt-used rpc-buffer-pair ((obj rpc-buffer-pair))
(if (> (-> obj current elt-used) 0)
(set! (-> obj current elt-used) (+ (-> obj current elt-used) -1))
)
0
)
;; failed to figure out what this is:
(let ((v0-2 0))
)

32
test/offline/offline_test_main.cpp
View file

@ -14,17 +14,14 @@ namespace fs = std::filesystem;
namespace {
// list of object files to ignore during reference checks
const std::unordered_set<std::string> g_object_files_to_ignore_ref_checks = {
"pskernel", "geometry", "timer", "texture",
"ocean-tables", "ocean-frames", "time-of-day", "display"};
const std::unordered_set<std::string> g_object_files_to_ignore_decompiling = {
// TODO - not implemented, if you want to ignore decompiling something currently, don't include
// it in the reference folder
const std::unordered_set<std::string> g_files_to_skip_compiling = {
"timer", // accessing timer regs
"display", // interrupt handlers
"game-info-h", // variable scoped at object file top-level issue.
};
// the functions we expect the decompiler to skip
const std::unordered_set<std::string> expected_skip_in_decompiler = {
const std::unordered_set<std::string> g_functions_expected_to_reject = {
// gcommon
"quad-copy!", // asm mempcy
// gkernel
@ -70,7 +67,7 @@ const std::unordered_set<std::string> expected_skip_in_decompiler = {
"(method 15 sync-info-paused)", // needs *res-static-buf*
};
const std::unordered_set<std::string> skip_in_compiling = {
const std::unordered_set<std::string> g_functions_to_skip_compiling = {
/// GCOMMON
// these functions are not implemented by the compiler in OpenGOAL, but are in GOAL.
"abs", "ash", "min", "max", "lognor",
@ -133,6 +130,9 @@ const std::unordered_set<std::string> skip_in_compiling = {
// bad decisions on float vs int128
"vector-degf", "vector-degmod", "vector-deg-diff", "vector-degi",
// asm
"invalidate-cache-line",
// capture
"(method 3 gs-store-image-packet)", // print giftag weirdness
@ -330,8 +330,8 @@ TEST_F(OfflineDecompilation, AsmFunction) {
int failed_count = 0;
db->for_each_function([&](decompiler::Function& func, int, decompiler::ObjectFileData&) {
if (func.suspected_asm) {
if (expected_skip_in_decompiler.find(func.guessed_name.to_string()) ==
expected_skip_in_decompiler.end()) {
if (g_functions_expected_to_reject.find(func.guessed_name.to_string()) ==
g_functions_expected_to_reject.end()) {
lg::error("Function {} was marked as asm, but wasn't expected.",
func.guessed_name.to_string());
failed_count++;
@ -458,11 +458,6 @@ void strip_trailing_newlines(std::string& in) {
TEST_F(OfflineDecompilation, Reference) {
for (auto& file : g_object_files_to_decompile_or_ref_check) {
if (g_object_files_to_ignore_ref_checks.find(file.first) !=
g_object_files_to_ignore_ref_checks.end()) {
continue;
}
auto& obj_l = db->obj_files_by_name.at(file.first);
ASSERT_EQ(obj_l.size(), 1);
@ -513,8 +508,7 @@ TEST_F(OfflineDecompilation, Compile) {
Timer timer;
int total_lines = 0;
for (auto& file : g_object_files_to_decompile_or_ref_check) {
if (g_object_files_to_ignore_ref_checks.find(file.first) !=
g_object_files_to_ignore_ref_checks.end()) {
if (g_files_to_skip_compiling.find(file.first) != g_files_to_skip_compiling.end()) {
continue;
}
@ -523,7 +517,7 @@ TEST_F(OfflineDecompilation, Compile) {
auto& obj_l = db->obj_files_by_name.at(file.first);
ASSERT_EQ(obj_l.size(), 1);
std::string src = db->ir2_final_out(obj_l.at(0), skip_in_compiling);
std::string src = db->ir2_final_out(obj_l.at(0), g_functions_to_skip_compiling);
total_lines += line_count(src);
compiler.run_full_compiler_on_string_no_save(src);