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-run (function none))
(define-extern mc-check-result (function int)) (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 ;;;;;;;;;;;;;;;;;;; ;;;; GCOMMON ;;;;;;;;;;;;;;;;;;;
@ -8504,6 +8520,11 @@
:flag-assert #x900000090 :flag-assert #x900000090
) )
;;;; engine
(define-extern *background-draw-engine* engine)
(define-extern *camera-engine* engine)
(define-extern *debug-engine* engine)
;; res-h ;; res-h
(deftype res-tag (uint128) (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 ;; load-dgo
(deftype load-dgo-msg (structure) (deftype load-dgo-msg (structure)
((rsvd uint16 :offset-assert 0) ((rsvd uint16 :offset-assert 0)
(result uint16 :offset-assert 2) (result load-msg-result :offset-assert 2)
(b1 uint32 :offset-assert 4) (b1 uint32 :offset-assert 4)
(b2 uint32 :offset-assert 8) (b2 uint32 :offset-assert 8)
(bt uint32 :offset-assert 12) (bt uint32 :offset-assert 12)
;(name uint128 :offset-assert 16) (name uint128 :offset-assert 16)
(name uint8 16 :offset-assert 16) (name-chars uint8 16 :offset 16)
(address uint32 :offset 4) (address uint32 :offset 4)
) )
:method-count-assert 9 :method-count-assert 9
@ -13166,7 +13203,7 @@
;; load-dgo ;; load-dgo
(deftype load-chunk-msg (structure) (deftype load-chunk-msg (structure)
((rsvd uint16 :offset-assert 0) ((rsvd uint16 :offset-assert 0)
(result uint16 :offset-assert 2) (result load-msg-result :offset-assert 2)
(address pointer :offset-assert 4) (address pointer :offset-assert 4)
(section uint32 :offset-assert 8) (section uint32 :offset-assert 8)
(maxlen uint32 :offset-assert 12) (maxlen uint32 :offset-assert 12)
@ -13182,23 +13219,51 @@
(deftype dgo-header (structure) (deftype dgo-header (structure)
((length uint32 :offset-assert 0) ((length uint32 :offset-assert 0)
(rootname uint8 60 :offset-assert 4) (rootname uint8 60 :offset-assert 4)
;; added
(data uint8 :dynamic :offset-assert 64)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x40 :size-assert #x40
:flag-assert #x900000040 :flag-assert #x900000040
) )
; ;; ramdisk (define-extern *load-dgo-rpc* rpc-buffer-pair)
; (deftype ramdisk-rpc-fill (structure) (define-extern *load-str-rpc* rpc-buffer-pair)
; ((rsvd1 int32 :offset-assert 0) (define-extern *play-str-rpc* rpc-buffer-pair)
; (ee-id int32 :offset-assert 4) (define-extern *load-str-lock* symbol)
; (rsvd2 UNKNOWN 2 :offset-assert 8) (define-extern *que-str-lock* symbol)
; (filename uint128 :offset-assert 16) (define-extern *dgo-name* string)
; ) (define-extern str-load (function string int pointer int symbol))
; :method-count-assert 9 (define-extern str-load-status (function (pointer int32) symbol))
; :size-assert #x20 (define-extern str-load-cancel (function none))
; :flag-assert #x900000020 (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 ;; ramdisk
(deftype ramdisk-rpc-load (structure) (deftype ramdisk-rpc-load (structure)
@ -13225,6 +13290,11 @@
:flag-assert #x900000020 :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 ; ;; gsound
; (deftype sound-iop-info (basic) ; (deftype sound-iop-info (basic)
; ((frame uint32 :offset-assert 16) ; ((frame uint32 :offset-assert 16)
@ -33538,7 +33608,7 @@
(define-extern art-joint-anim type) (define-extern art-joint-anim type)
(define-extern joint-anim-compressed type) (define-extern joint-anim-compressed type)
(define-extern art-joint-geo 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 merc-fragment-fp-data (function merc-fragment pointer))
(define-extern ripple-wave-set type) (define-extern ripple-wave-set type)
(define-extern merc-ctrl type) (define-extern merc-ctrl type)
@ -33563,10 +33633,9 @@
(define-extern *merc-globals* symbol) ;; unknown type (define-extern *merc-globals* symbol) ;; unknown type
(define-extern *matrix-engine* (array handle)) ;; unknown type (define-extern *matrix-engine* (array handle)) ;; unknown type
;;(define-extern camera-eng object) ;; 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 draw object) ;; unknown type
;;(define-extern *debug-engine* object) ;; unknown type
(define-extern *res-key-string* string) ;; unknown type (define-extern *res-key-string* string) ;; unknown type
(define-extern *res-static-buf* pointer) ;; unknown type (define-extern *res-static-buf* pointer) ;; unknown type
(define-extern part-group-pointer? function) (define-extern part-group-pointer? function)
@ -33867,38 +33936,12 @@
;;(define-extern nav-max-users object) ;; unknown type ;;(define-extern nav-max-users object) ;; unknown type
;;(define-extern nav-engine object) ;; unknown type ;;(define-extern nav-engine object) ;; unknown type
;;(define-extern nearest-y-threshold 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 complete object) ;; unknown type
;;(define-extern busy object) ;; unknown type ;;(define-extern busy object) ;; unknown type
;;(define-extern link-begin 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 swap-sound-buffers function)
(define-extern sound-group-stop function) (define-extern sound-group-stop function)
(define-extern sound-set-ear-trans function) (define-extern sound-set-ear-trans function)
@ -34820,9 +34863,9 @@
(define-extern save-boundary-cmd function) (define-extern save-boundary-cmd function)
(define-extern command-get-int function) (define-extern command-get-int function)
(define-extern check-boundary 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 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 lb-add-vtx-before function)
(define-extern draw-boundary-polygon function) (define-extern draw-boundary-polygon function)
(define-extern load-boundary-from-template function) (define-extern load-boundary-from-template function)
@ -34840,7 +34883,7 @@
(define-extern lb-set-camera function) (define-extern lb-set-camera function)
(define-extern draw-boundary-cap function) (define-extern draw-boundary-cap function)
(define-extern lb-add 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 render-boundary function)
(define-extern init-boundary-regs function) (define-extern init-boundary-regs function)
(define-extern lb-del function) (define-extern lb-del function)
@ -34956,7 +34999,7 @@
(define-extern level-update-after-load function) (define-extern level-update-after-load function)
(define-extern update-sound-banks function) (define-extern update-sound-banks function)
(define-extern add-bsp-drawable 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 link-resume object) ;; unknown type
;;(define-extern display-self object) ;; unknown type ;;(define-extern display-self object) ;; unknown type
;;(define-extern loading-done 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], ["L28", "level-load-info", true],
["L544", "level-load-info", true], ["L544", "level-load-info", true],
["L2", "pair", 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"], [144, "vector4s-3"],
[192, "vector"], [192, "vector"],
[208, "vector4s-3"] [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)": [ "(method 0 align-control)": [
[[8, 13], "t9", "(function object object)"], [[8, 13], "t9", "(function object object)"],
[14, "v0", "align-control"] [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)": { "(method 0 align-control)": {
"vars":{"v0-0": ["obj", "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 * Allocate a structure with a dynamic size
*/ */
u64 new_dynamic_structure(u32 heap, u32 type, u32 size) { u64 new_dynamic_structure(u32 heap_symbol, u32 type, u32 size) {
return alloc_from_heap(heap, type, size); return alloc_from_heap(heap_symbol, type, size);
} }
/*! /*!

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

@ -59,20 +59,15 @@
) )
) )
(defmethod (defmethod new joint-anim-frame ((allocation symbol) (type-to-make type) (arg0 int))
new
joint-anim-frame
((allocation symbol) (type-to-make type) (arg0 int))
(let ((v1-1 (max 0 (+ arg0 -2)))) (let ((v1-1 (max 0 (+ arg0 -2))))
(the-as (the-as joint-anim-frame
joint-anim-frame (new-dynamic-structure
(new-dynamic-structure allocation
(the-as kheap allocation) type-to-make
type-to-make (the-as int (+ (-> type-to-make size) (the-as uint (* 48 v1-1)))))
(the-as int (+ (-> type-to-make size) (the-as uint (* 48 v1-1)))) )
)
) )
)
) )
(deftype joint-anim-compressed-hdr (structure) (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) (define-perm *palette-fade-controls* palette-fade-controls
(if (or (not *palette-fade-controls*) (zero? *palette-fade-controls*)) (new 'global 'palette-fade-controls)
(set!
*palette-fade-controls*
(the-as palette-fade-controls (new 'global 'palette-fade-controls))
)
) )
(deftype time-of-day-proc (process) (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 ;; name in dgo: load-dgo
;; dgos: GAME, ENGINE ;; 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) (deftype load-dgo-msg (structure)
((rsvd uint16 :offset-assert 0) ((rsvd uint16 :offset-assert 0) ;; unused?
(result uint16 :offset-assert 2) (result load-msg-result :offset-assert 2) ;; status from OVERLORD
(b1 uint32 :offset-assert 4) (b1 uint32 :offset-assert 4) ;; EE -> OVERLORD, first temp load buffer
(b2 uint32 :offset-assert 8) (b2 uint32 :offset-assert 8) ;; EE -> OVERLORD, second temp load buffer
(bt uint32 :offset-assert 12) (bt uint32 :offset-assert 12) ;; EE -> OVERLORD, location of heap
;(name uint128 :offset-assert 16) (name uint128 :offset-assert 16) ;; EE -> OVERLORD, name of file.
(name uint8 16 :offset-assert 16) (name-chars uint8 16 :offset 16) ;; name of file (as chars)
(address uint32 :offset 4) (address uint32 :offset 4) ;; OVERLORD -> EE, location of loaded file.
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x20 :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) (deftype load-chunk-msg (structure)
((rsvd uint16 :offset-assert 0) ((rsvd uint16 :offset-assert 0) ;; unused?
(result uint16 :offset-assert 2) (result load-msg-result :offset-assert 2) ;; only done or error.
(address pointer :offset-assert 4) (address pointer :offset-assert 4) ;; where to load to
(section uint32 :offset-assert 8) (section uint32 :offset-assert 8) ;; chunk ID, or -1 for the whole file.
(maxlen uint32 :offset-assert 12) (maxlen uint32 :offset-assert 12) ;; maximum length to load.
(id uint32 :offset 4) (id uint32 :offset 4) ;; ? same as chunk
(basename uint8 48 :offset-assert 16) (basename uint8 48 :offset-assert 16) ;; name of file to load.
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x40 :size-assert #x40
@ -57,9 +77,12 @@ struct RPC_Str_Cmd {
}; };
|# |#
;; The header of a DGO file
(deftype dgo-header (structure) (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) (rootname uint8 60 :offset-assert 4)
;; added data field
(data uint8 :dynamic :offset-assert 64)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x40 :size-assert #x40
@ -73,38 +96,52 @@ struct DgoHeader {
}; };
|# |#
;;;;;;;;;;;;;;;;;;;;;;;;;
;; RPC Buffer init
;;;;;;;;;;;;;;;;;;;;;;;;;
(define-extern *load-dgo-rpc* rpc-buffer-pair) (define-extern *load-dgo-rpc* rpc-buffer-pair)
(when (= 0 (the int *load-dgo-rpc*)) (when (= 0 (the int *load-dgo-rpc*))
;; we need to allocate the rpc buffers ;; 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 (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 *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)) (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 *load-str-lock* '#f)
(define *que-str-lock* '#f) (define *que-str-lock* '#f)
(define *dgo-name* (new 'global 'string 64 (the string '#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)) (defun str-load ((name string) (chunk-id int) (address pointer) (len int))
"Begin a streaming load if possible! "Begin a streaming load if possible!
We must be able to grab the lock, and no streaming load in progress. We must be able to grab the lock, and no streaming load in progress.
Return if we actually start the load." Return if we actually start the load."
;; call method 13
(when (or (check-busy *load-str-rpc*) ;; check if safe to begin load.
*load-str-lock* (when (or (check-busy *load-str-rpc*) *load-str-lock*)
) (return #f)
(return-from #f '#f) )
)
;; ok, we are good to start a load. begin by adding an element to the RPC buffer ;; 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*)))) (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 address) address)
(set! (-> cmd section) chunk-id) (set! (-> cmd section) chunk-id)
(set! (-> cmd maxlen) len) (set! (-> cmd maxlen) len)
(charp<-string (-> cmd basename) name) (charp<-string (-> cmd basename) name)
;; and then calling with this element
(call *load-str-rpc* (the uint 0) (the pointer cmd) (the uint 32)) (call *load-str-rpc* (the uint 0) (the pointer cmd) (the uint 32))
(set! *load-str-lock* '#t) (set! *load-str-lock* #t)
(set! *que-str-lock* '#t) (set! *que-str-lock* #t)
'#t #t
) )
) )
@ -114,21 +151,313 @@ struct DgoHeader {
The 'error status indicates the load failed. The 'error status indicates the load failed.
The 'complete status means the load is finished, and length-out contains the loaded length." The 'complete status means the load is finished, and length-out contains the loaded length."
;; still going.. ;; still going..
(if (check-busy *load-str-rpc*) (if (check-busy *load-str-rpc*)
(return-from #f 'busy) (return 'busy)
) )
;; not busy, we can free the lock ;; not busy, we can free the lock
(set! *load-str-lock* '#f) (set! *load-str-lock* #f)
(set! *que-str-lock* '#t) ;; also lock the queue. Not sure why?
;; grab the response (set! *que-str-lock* #t)
(let ((response (the load-chunk-msg (pop-last-received *load-str-rpc*)))) ;; grab the response
(if (= 1 (-> response result)) (let ((response (the load-chunk-msg (pop-last-received *load-str-rpc*))))
(return-from #f 'error) (if (= (-> response result) (load-msg-result error))
) (return 'error)
;; no error! )
(set! (-> length-out) (the int (-> response maxlen))) ;; no error!
'complete (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 ;; name in dgo: ramdisk
;; dgos: GAME, ENGINE ;; 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 v0-0
) )
;; TODO - show-mc-info - failed to decompile (defun show-mc-info ((dma-buf dma-buffer))
;; WARN: Type Propagation failed: Failed to find a stack variable at offset 16 "Print mc info to the screen."
;; WARN: Type Propagation failed: Type analysis failed (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) (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 string->symbol (function string symbol))
(define-extern print (function object object)) (define-extern print (function object object))
(define-extern inspect (function object object)) (define-extern inspect (function object object))
@ -83,11 +95,11 @@
(define-extern _format (function _varargs_ object)) (define-extern _format (function _varargs_ object))
(define-extern malloc (function symbol int pointer)) (define-extern malloc (function symbol int pointer))
(define-extern kmalloc (function kheap int kmalloc-flags string 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 method-set! (function type int function none)) ;; may actually return function.
(define-extern link (function pointer pointer int kheap int pointer)) (define-extern link (function pointer pointer int kheap int pointer))
(define-extern dgo-load (function string kheap int int none)) (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 link-resume (function int))
(define-extern mc-run (function none)) (define-extern mc-run (function none))
;; mc-format ;; mc-format
@ -95,8 +107,11 @@
;; mc-create-file ;; mc-create-file
;; mc-save ;; mc-save
;; mc-load ;; 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)) (define-extern mc-check-result (function int))
;; mc-get-slot-info
;; mc-makefile ;; mc-makefile
;; kset-language ;; kset-language

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

@ -482,6 +482,17 @@
:flag-assert #x900000010 :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) (deftype attack-info (structure)
((trans vector :inline :offset-assert 0) ((trans vector :inline :offset-assert 0)
(vector vector :inline :offset-assert 16) (vector vector :inline :offset-assert 16)
@ -589,6 +600,48 @@
(define-extern sprite-distorter-generate-tables (function none)) (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 () (defmacro init-vf0-vector ()
"Initializes the VF0 vector which is a constant vector in the VU set to <0,0,0,1>" "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)) `(.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 smode2) (new 'static 'gs-smode2 :int #x1 :ffmd #x1))
(set! (set!
(-> env dspfb) (-> 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! (set!
(-> env display) (-> env display)
@ -61,7 +61,7 @@
:dw #x9ff :dw #x9ff
:dy (+ dy 50) :dy (+ dy 50)
:dx (+ (* dx (/ 2560 width)) 652) :dx (+ (* dx (/ 2560 width)) 652)
:dh (+ (shl height 1) -1) :dh (+ (* height 2) -1)
:magh (+ (/ (+ width 2559) width) -1) :magh (+ (/ (+ width 2559) width) -1)
) )
) )
@ -83,7 +83,7 @@
(set! (-> env frame1addr) (gs-reg64 frame-1)) (set! (-> env frame1addr) (gs-reg64 frame-1))
(set! (set!
(-> env frame1) (-> 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)) (set! (-> env dtheaddr) (gs-reg64 dthe))
(cond (cond
@ -121,7 +121,7 @@
(-> env xyoffset1) (-> env xyoffset1)
(new 'static 'gs-xy-offset (new 'static 'gs-xy-offset
:ofx #x7000 :ofx #x7000
:ofy (shl (-> *video-parms* screen-miny) 4) :ofy (* (-> *video-parms* screen-miny) 16)
) )
) )
(set! (-> env scissor1addr) (gs-reg64 scissor-1)) (set! (-> env scissor1addr) (gs-reg64 scissor-1))
@ -141,8 +141,8 @@
(set! (set!
(-> env xyoffset1) (-> env xyoffset1)
(new 'static 'gs-xy-offset (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) :ofx (* (- x (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scax1)) (the-as uint 1))) 1))) 16)
: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)) :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 env
@ -283,7 +283,7 @@
;; definition for method 11 of type profile-bar ;; definition for method 11 of type profile-bar
(defmethod add-frame profile-bar ((obj profile-bar) (name symbol) (color rgba)) (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)))) (let ((new-frame (-> obj data (-> obj profile-frame-count))))
(set! (-> obj profile-frame-count) (+ (-> obj profile-frame-count) 1)) (set! (-> obj profile-frame-count) (+ (-> obj profile-frame-count) 1))
(set! (-> new-frame name) name) (set! (-> new-frame name) name)
@ -341,7 +341,7 @@
) )
(let ((block-idx 1) (let ((block-idx 1)
(block-count (-> obj profile-frame-count)) (block-count (-> obj profile-frame-count))
(left (shl *profile-x* 4)) (left (* *profile-x* 16))
(end-time 0) (end-time 0)
(worst-time-cache (new 'static 'array uint32 2 #x0 #x0)) (worst-time-cache (new 'static 'array uint32 2 #x0 #x0))
) )
@ -355,10 +355,7 @@
) )
(set! (set!
(-> direct-tag dma) (-> direct-tag dma)
(new 'static 'dma-tag (new 'static 'dma-tag :id (dma-tag-id cnt) :qwc (+ (* block-count 2) -1))
:id (dma-tag-id cnt)
:qwc (+ (shl block-count 1) -1)
)
) )
(set! (-> direct-tag vif0) (new 'static 'vif-tag)) (set! (-> direct-tag vif0) (new 'static 'vif-tag))
(set! (set!
@ -366,7 +363,7 @@
(new 'static 'vif-tag (new 'static 'vif-tag
:cmd (vif-cmd direct) :cmd (vif-cmd direct)
:msk #x1 :msk #x1
:imm (+ (shl block-count 1) -1) :imm (+ (* block-count 2) -1)
) )
) )
(set! (-> t1-0 base) (&+ (the-as pointer direct-tag) 16)) (set! (-> t1-0 base) (&+ (the-as pointer direct-tag) 16))
@ -410,7 +407,7 @@
(-> (the-as (pointer gs-xyzf) t3-8) 2) (-> (the-as (pointer gs-xyzf) t3-8) 2)
(new 'static 'gs-xyzf (new 'static 'gs-xyzf
:z #x3fffff :z #x3fffff
:y (shl (+ *profile-y* screen-y) 4) :y (* (+ *profile-y* screen-y) 16)
:x left :x left
) )
) )
@ -421,7 +418,7 @@
) )
(set! (set!
left left
(shl (*
(+ (+
*profile-x* *profile-x*
(the-as (the-as
@ -432,7 +429,7 @@
) )
) )
) )
4 16
) )
) )
) )
@ -443,7 +440,7 @@
(-> (the-as (pointer gs-xyzf) t2-8) 0) (-> (the-as (pointer gs-xyzf) t2-8) 0)
(new 'static 'gs-xyzf (new 'static 'gs-xyzf
:z #x3fffff :z #x3fffff
:y (shl (+ (+ *profile-y* screen-y) *profile-h*) 4) :y (* (+ (+ *profile-y* screen-y) *profile-h*) 16)
:x left :x left
) )
) )
@ -573,21 +570,21 @@
) )
(set! (set!
(-> (the-as (pointer gs-xyzf) gif-buf) 2) (-> (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! (set!
(-> (the-as (pointer gs-xyzf) gif-buf) 3) (-> (the-as (pointer gs-xyzf) gif-buf) 3)
(new 'static 'gs-xyzf (new 'static 'gs-xyzf
:z #x3fffff :z #x3fffff
:y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4) :y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16)
:x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4) :x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16)
) )
) )
(set! (-> a2-4 base) (&+ gif-buf 32)) (set! (-> a2-4 base) (&+ gif-buf 32))
) )
(let (let
((total-qwc ((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 (cond
@ -676,7 +673,7 @@
) )
(set! (set!
(-> (the-as (pointer gs-xyzf) gif-buf) 2) (-> (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! (set!
(-> (the-as (pointer gs-rgbaq) gif-buf) 3) (-> (the-as (pointer gs-rgbaq) gif-buf) 3)
@ -685,8 +682,8 @@
(set! (set!
(-> (the-as (pointer gs-xyzf) gif-buf) 4) (-> (the-as (pointer gs-xyzf) gif-buf) 4)
(new 'static 'gs-xyzf (new 'static 'gs-xyzf
:y (shl draw-y 4) :y (* draw-y 16)
:x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4) :x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16)
) )
) )
(set! (set!
@ -696,8 +693,8 @@
(set! (set!
(-> (the-as (pointer gs-xyzf) gif-buf) 6) (-> (the-as (pointer gs-xyzf) gif-buf) 6)
(new 'static 'gs-xyzf (new 'static 'gs-xyzf
:y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4) :y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16)
:x (shl draw-x 4) :x (* draw-x 16)
) )
) )
(set! (set!
@ -707,14 +704,14 @@
(set! (set!
(-> (the-as (pointer gs-xyzf) gif-buf) 8) (-> (the-as (pointer gs-xyzf) gif-buf) 8)
(new 'static 'gs-xyzf (new 'static 'gs-xyzf
:y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4) :y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16)
:x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4) :x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16)
) )
) )
(set! (-> (the-as (pointer uint64) gif-buf) 9) (the-as uint 0)) (set! (-> (the-as (pointer uint64) gif-buf) 9) (the-as uint 0))
(set! (-> t0-2 base) (&+ gif-buf 80)) (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 (cond
((nonzero? total-qwc) ((nonzero? total-qwc)
(set! (set!
@ -794,7 +791,7 @@
(defun (defun
set-display-gs-state set-display-gs-state
((dma-buf dma-buffer) (fbp int) (scx int) (scy int) (fb-msk int) (psm int)) ((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) (let* ((v1-1 dma-buf)
(dma (the-as dma-packet (-> v1-1 base))) (dma (the-as dma-packet (-> v1-1 base)))
) )
@ -886,7 +883,7 @@
(off-x int) (off-x int)
(off-y int) (off-y int)
) )
(let ((fbw (sar (+ width 63) 6))) (let ((fbw (/ (+ width 63) 64)))
(let* ((v1-1 dma-buf) (let* ((v1-1 dma-buf)
(dma (the-as dma-packet (-> v1-1 base))) (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-reg64) gif-data) 1) (gs-reg64 scissor-1))
(set! (set!
(-> (the-as (pointer gs-xy-offset) gif-data) 2) (-> (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! (-> (the-as (pointer gs-reg64) gif-data) 3) (gs-reg64 xyoffset-1))
(set! (set!
@ -970,7 +967,7 @@
;; INFO: Return type mismatch display vs none. ;; INFO: Return type mismatch display vs none.
(defun reset-display-gs-state ((disp display) (dma-buf dma-buffer) (oddeven int)) (defun reset-display-gs-state ((disp display) (dma-buf dma-buffer) (oddeven int))
(let* ((onscreen (-> disp on-screen)) (let* ((onscreen (-> disp on-screen))
(hoff (shl oddeven 3)) (hoff (* oddeven 8))
(fbp (-> disp frames onscreen draw frame1 fbp)) (fbp (-> disp frames onscreen draw frame1 fbp))
) )
(let* ((a3-1 dma-buf) (let* ((a3-1 dma-buf)
@ -1024,7 +1021,7 @@
(-> (the-as (pointer gs-xy-offset) gif-data) 2) (-> (the-as (pointer gs-xy-offset) gif-data) 2)
(new 'static 'gs-xy-offset (new 'static 'gs-xy-offset
:ofx #x7000 :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)) (set! (-> (the-as (pointer gs-reg64) gif-data) 3) (gs-reg64 xyoffset-1))
@ -1064,7 +1061,3 @@
;; failed to figure out what this is: ;; failed to figure out what this is:
(allocate-dma-buffers *display*) (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 { namespace {
// list of object files to ignore during reference checks // list of object files to ignore during reference checks
const std::unordered_set<std::string> g_object_files_to_ignore_ref_checks = { const std::unordered_set<std::string> g_files_to_skip_compiling = {
"pskernel", "geometry", "timer", "texture", "timer", // accessing timer regs
"ocean-tables", "ocean-frames", "time-of-day", "display"}; "display", // interrupt handlers
"game-info-h", // variable scoped at object file top-level issue.
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
}; };
// the functions we expect the decompiler to skip // 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 // gcommon
"quad-copy!", // asm mempcy "quad-copy!", // asm mempcy
// gkernel // gkernel
@ -70,7 +67,7 @@ const std::unordered_set<std::string> expected_skip_in_decompiler = {
"(method 15 sync-info-paused)", // needs *res-static-buf* "(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 /// GCOMMON
// these functions are not implemented by the compiler in OpenGOAL, but are in GOAL. // these functions are not implemented by the compiler in OpenGOAL, but are in GOAL.
"abs", "ash", "min", "max", "lognor", "abs", "ash", "min", "max", "lognor",
@ -133,6 +130,9 @@ const std::unordered_set<std::string> skip_in_compiling = {
// bad decisions on float vs int128 // bad decisions on float vs int128
"vector-degf", "vector-degmod", "vector-deg-diff", "vector-degi", "vector-degf", "vector-degmod", "vector-deg-diff", "vector-degi",
// asm
"invalidate-cache-line",
// capture // capture
"(method 3 gs-store-image-packet)", // print giftag weirdness "(method 3 gs-store-image-packet)", // print giftag weirdness
@ -330,8 +330,8 @@ TEST_F(OfflineDecompilation, AsmFunction) {
int failed_count = 0; int failed_count = 0;
db->for_each_function([&](decompiler::Function& func, int, decompiler::ObjectFileData&) { db->for_each_function([&](decompiler::Function& func, int, decompiler::ObjectFileData&) {
if (func.suspected_asm) { if (func.suspected_asm) {
if (expected_skip_in_decompiler.find(func.guessed_name.to_string()) == if (g_functions_expected_to_reject.find(func.guessed_name.to_string()) ==
expected_skip_in_decompiler.end()) { g_functions_expected_to_reject.end()) {
lg::error("Function {} was marked as asm, but wasn't expected.", lg::error("Function {} was marked as asm, but wasn't expected.",
func.guessed_name.to_string()); func.guessed_name.to_string());
failed_count++; failed_count++;
@ -458,11 +458,6 @@ void strip_trailing_newlines(std::string& in) {
TEST_F(OfflineDecompilation, Reference) { TEST_F(OfflineDecompilation, Reference) {
for (auto& file : g_object_files_to_decompile_or_ref_check) { 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); auto& obj_l = db->obj_files_by_name.at(file.first);
ASSERT_EQ(obj_l.size(), 1); ASSERT_EQ(obj_l.size(), 1);
@ -513,8 +508,7 @@ TEST_F(OfflineDecompilation, Compile) {
Timer timer; Timer timer;
int total_lines = 0; int total_lines = 0;
for (auto& file : g_object_files_to_decompile_or_ref_check) { for (auto& file : g_object_files_to_decompile_or_ref_check) {
if (g_object_files_to_ignore_ref_checks.find(file.first) != if (g_files_to_skip_compiling.find(file.first) != g_files_to_skip_compiling.end()) {
g_object_files_to_ignore_ref_checks.end()) {
continue; continue;
} }
@ -523,7 +517,7 @@ TEST_F(OfflineDecompilation, Compile) {
auto& obj_l = db->obj_files_by_name.at(file.first); auto& obj_l = db->obj_files_by_name.at(file.first);
ASSERT_EQ(obj_l.size(), 1); 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); total_lines += line_count(src);
compiler.run_full_compiler_on_string_no_save(src); compiler.run_full_compiler_on_string_no_save(src);