From ec412c7777005ccd73fdc0e83de40eb209090156 Mon Sep 17 00:00:00 2001 From: water111 <48171810+water111@users.noreply.github.com> Date: Sun, 16 May 2021 21:07:22 -0400 Subject: [PATCH] [decomp] ramdisk, load-dgo and rpc-h (#496) * decompile ramdisk load-dgo and rpc-h * add a bunch of offline tests * clang-format --- decompiler/config/all-types.gc | 147 ++-- .../jak1_ntsc_black_label/label_types.jsonc | 4 + .../jak1_ntsc_black_label/stack_vars.jsonc | 4 + .../jak1_ntsc_black_label/type_casts.jsonc | 52 ++ .../jak1_ntsc_black_label/var_names.jsonc | 79 ++ game/kernel/kscheme.cpp | 4 +- goal_src/engine/data/art-h.gc | 19 +- goal_src/engine/gfx/time-of-day-h.gc | 8 +- goal_src/engine/load/load-dgo.gc | 413 +++++++++- goal_src/engine/load/ramdisk.gc | 64 ++ goal_src/engine/ps2/memcard-h.gc | 38 +- goal_src/kernel-defs.gc | 21 +- .../reference/all_forward_declarations.gc | 53 ++ .../reference/engine/anim/bones-h_REF.gc | 234 ++++++ .../reference/engine/anim/joint-h_REF.gc | 200 +++++ .../reference/engine/data/art-h_REF.gc | 506 ++++++++++++ .../reference/engine/engine/engine_REF.gc | 26 + .../reference/engine/game/game-info-h_REF.gc | 303 ++++++++ .../engine/gfx/generic/generic-vu1-h_REF.gc | 88 +++ .../engine/gfx/generic/generic-work-h_REF.gc | 193 +++++ .../reference/engine/gfx/hw/display_REF.gc | 69 +- .../engine/gfx/merc/generic-merc-h_REF.gc | 289 +++++++ .../reference/engine/gfx/merc/merc-h_REF.gc | 726 ++++++++++++++++++ .../engine/gfx/tie/generic-tie-h_REF.gc | 472 ++++++++++++ .../engine/gfx/tie/prototype-h_REF.gc | 272 +++++++ .../reference/engine/gfx/time-of-day-h_REF.gc | 226 ++++++ .../reference/engine/load/load-dgo_REF.gc | 461 +++++++++++ .../reference/engine/load/ramdisk_REF.gc | 109 +++ .../reference/engine/ps2/memcard-h_REF.gc | 164 ++++ .../reference/engine/ps2/rpc-h_REF.gc | 252 ++++++ test/offline/offline_test_main.cpp | 32 +- 31 files changed, 5351 insertions(+), 177 deletions(-) create mode 100644 test/decompiler/reference/engine/anim/bones-h_REF.gc create mode 100644 test/decompiler/reference/engine/anim/joint-h_REF.gc create mode 100644 test/decompiler/reference/engine/data/art-h_REF.gc create mode 100644 test/decompiler/reference/engine/engine/engine_REF.gc create mode 100644 test/decompiler/reference/engine/game/game-info-h_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/generic/generic-vu1-h_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/generic/generic-work-h_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/merc/generic-merc-h_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/tie/generic-tie-h_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/tie/prototype-h_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/time-of-day-h_REF.gc create mode 100644 test/decompiler/reference/engine/load/load-dgo_REF.gc create mode 100644 test/decompiler/reference/engine/load/ramdisk_REF.gc create mode 100644 test/decompiler/reference/engine/ps2/memcard-h_REF.gc create mode 100644 test/decompiler/reference/engine/ps2/rpc-h_REF.gc diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc index b473fe715..ac4b06965 100644 --- a/decompiler/config/all-types.gc +++ b/decompiler/config/all-types.gc @@ -80,6 +80,22 @@ (define-extern mc-run (function none)) (define-extern mc-check-result (function int)) +(defenum link-flag + :bitfield #t + :type int32 + (output-load-msg 0) + (output-load-true-msg 1) + (execute-login 2) + (print-login 3) + (force-debug 4) + (fast-link 5) + ) + +(define-extern link-begin (function pointer (pointer uint8) int kheap link-flag int)) + +(define-extern rpc-call (function int uint uint uint int uint int uint)) +(define-extern rpc-busy? (function int uint)) + ;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;; GCOMMON ;;;;;;;;;;;;;;;;;;; @@ -8504,6 +8520,11 @@ :flag-assert #x900000090 ) +;;;; engine +(define-extern *background-draw-engine* engine) +(define-extern *camera-engine* engine) +(define-extern *debug-engine* engine) + ;; res-h (deftype res-tag (uint128) @@ -13147,15 +13168,31 @@ ; ) ; ) +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; LOAD-DGO ;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; + +(defenum load-msg-result + :type uint16 + :bitfield #f + (done 0) + (error 1) + (more 2) + (aborted 3) + (invalid 666) + ) + ;; load-dgo (deftype load-dgo-msg (structure) ((rsvd uint16 :offset-assert 0) - (result uint16 :offset-assert 2) + (result load-msg-result :offset-assert 2) (b1 uint32 :offset-assert 4) (b2 uint32 :offset-assert 8) (bt uint32 :offset-assert 12) - ;(name uint128 :offset-assert 16) - (name uint8 16 :offset-assert 16) + (name uint128 :offset-assert 16) + (name-chars uint8 16 :offset 16) (address uint32 :offset 4) ) :method-count-assert 9 @@ -13166,7 +13203,7 @@ ;; load-dgo (deftype load-chunk-msg (structure) ((rsvd uint16 :offset-assert 0) - (result uint16 :offset-assert 2) + (result load-msg-result :offset-assert 2) (address pointer :offset-assert 4) (section uint32 :offset-assert 8) (maxlen uint32 :offset-assert 12) @@ -13182,23 +13219,51 @@ (deftype dgo-header (structure) ((length uint32 :offset-assert 0) (rootname uint8 60 :offset-assert 4) + ;; added + (data uint8 :dynamic :offset-assert 64) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -; ;; ramdisk -; (deftype ramdisk-rpc-fill (structure) -; ((rsvd1 int32 :offset-assert 0) -; (ee-id int32 :offset-assert 4) -; (rsvd2 UNKNOWN 2 :offset-assert 8) -; (filename uint128 :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 -; ) +(define-extern *load-dgo-rpc* rpc-buffer-pair) +(define-extern *load-str-rpc* rpc-buffer-pair) +(define-extern *play-str-rpc* rpc-buffer-pair) +(define-extern *load-str-lock* symbol) +(define-extern *que-str-lock* symbol) +(define-extern *dgo-name* string) +(define-extern str-load (function string int pointer int symbol)) +(define-extern str-load-status (function (pointer int32) symbol)) +(define-extern str-load-cancel (function none)) +(define-extern str-play-async (function string pointer none)) +(define-extern str-play-stop (function string none)) +(define-extern str-play-queue (function string none)) +(define-extern str-ambient-play (function string none)) +(define-extern str-ambient-stop (function string none)) +(define-extern dgo-load-begin (function string int int int load-dgo-msg)) +(define-extern dgo-load-get-next (function (pointer symbol) pointer)) +(define-extern dgo-load-continue (function pointer int)) +(define-extern dgo-load-cancel (function none)) +(define-extern find-temp-buffer (function int pointer)) +(define-extern dgo-load-link (function dgo-header kheap symbol symbol symbol)) +(define-extern destroy-mem (function (pointer uint32) (pointer uint32) none)) +(define-extern string->sound-name (function string uint128)) +(define-extern str-play-kick (function none)) +(define-extern *dgo-time* uint) + + +;; ramdisk +(deftype ramdisk-rpc-fill (structure) + ((rsvd1 int32 :offset-assert 0) + (ee-id int32 :offset-assert 4) + (rsvd2 int32 2 :offset-assert 8) + (filename uint128 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) ;; ramdisk (deftype ramdisk-rpc-load (structure) @@ -13225,6 +13290,11 @@ :flag-assert #x900000020 ) +(define-extern *current-ramdisk-id* int) +(define-extern ramdisk-load (function int uint uint pointer int)) +(define-extern *ramdisk-rpc* rpc-buffer-pair) +(define-extern ramdisk-sync (function none)) + ; ;; gsound ; (deftype sound-iop-info (basic) ; ((frame uint32 :offset-assert 16) @@ -33538,7 +33608,7 @@ (define-extern art-joint-anim type) (define-extern joint-anim-compressed type) (define-extern art-joint-geo type) -(define-extern new-dynamic-structure (function kheap type int structure)) ;; unknown type +(define-extern new-dynamic-structure (function symbol type int structure)) ;; unknown type (define-extern merc-fragment-fp-data (function merc-fragment pointer)) (define-extern ripple-wave-set type) (define-extern merc-ctrl type) @@ -33563,10 +33633,9 @@ (define-extern *merc-globals* symbol) ;; unknown type (define-extern *matrix-engine* (array handle)) ;; unknown type ;;(define-extern camera-eng object) ;; unknown type -;;(define-extern *camera-engine* object) ;; unknown type -;;(define-extern *background-draw-engine* object) ;; unknown type + + ;;(define-extern draw object) ;; unknown type -;;(define-extern *debug-engine* object) ;; unknown type (define-extern *res-key-string* string) ;; unknown type (define-extern *res-static-buf* pointer) ;; unknown type (define-extern part-group-pointer? function) @@ -33867,38 +33936,12 @@ ;;(define-extern nav-max-users object) ;; unknown type ;;(define-extern nav-engine object) ;; unknown type ;;(define-extern nearest-y-threshold object) ;; unknown type -(define-extern dgo-load-begin (function int int int int int)) -(define-extern dgo-load-continue function) -(define-extern destroy-mem function) -(define-extern str-load (function string int pointer int symbol)) -(define-extern *load-str-rpc* rpc-buffer-pair) ;; unknown type -;;(define-extern *dgo-name* object) ;; unknown type -(define-extern str-ambient-play (function string none)) -(define-extern *load-str-lock* symbol) ;; unknown type -(define-extern str-load-status (function (pointer int32) symbol)) -(define-extern str-load-cancel (function none)) -(define-extern str-play-queue (function string none)) -(define-extern str-ambient-stop (function string none)) -(define-extern dgo-load-get-next function) -(define-extern find-temp-buffer function) -(define-extern str-play-kick (function none)) -(define-extern *load-dgo-rpc* rpc-buffer-pair) ;; unknown type -(define-extern *que-str-lock* symbol) ;; unknown type -(define-extern dgo-load-cancel function) -(define-extern dgo-load-link function) -;;(define-extern *dgo-time* object) ;; unknown type -(define-extern str-play-async (function string int none)) -(define-extern str-play-stop (function string none)) -(define-extern *play-str-rpc* rpc-buffer-pair) ;; unknown type -(define-extern string->sound-name function) + + ;;(define-extern complete object) ;; unknown type ;;(define-extern busy object) ;; unknown type ;;(define-extern link-begin object) ;; unknown type -;;(define-extern *current-ramdisk-id* object) ;; unknown type -(define-extern ramdisk-load function) -;;(define-extern *ramdisk-rpc* object) ;; unknown type -(define-extern ramdisk-sync function) -;;(define-extern ramdisk-rpc-fill object) ;; unknown type + (define-extern swap-sound-buffers function) (define-extern sound-group-stop function) (define-extern sound-set-ear-trans function) @@ -34820,9 +34863,9 @@ (define-extern save-boundary-cmd function) (define-extern command-get-int function) (define-extern check-boundary function) -(define-extern load-state-want-vis function) +(define-extern load-state-want-vis (function int none)) (define-extern add-boundary-shader function) -(define-extern load-state-want-levels function) +(define-extern load-state-want-levels (function int int none)) (define-extern lb-add-vtx-before function) (define-extern draw-boundary-polygon function) (define-extern load-boundary-from-template function) @@ -34840,7 +34883,7 @@ (define-extern lb-set-camera function) (define-extern draw-boundary-cap function) (define-extern lb-add function) -(define-extern load-state-want-display-level function) +(define-extern load-state-want-display-level (function int int none)) (define-extern render-boundary function) (define-extern init-boundary-regs function) (define-extern lb-del function) @@ -34956,7 +34999,7 @@ (define-extern level-update-after-load function) (define-extern update-sound-banks function) (define-extern add-bsp-drawable function) -;;(define-extern *print-login* object) ;; unknown type +(define-extern *print-login* symbol) ;; unknown type ;;(define-extern link-resume object) ;; unknown type ;;(define-extern display-self object) ;; unknown type ;;(define-extern loading-done object) ;; unknown type diff --git a/decompiler/config/jak1_ntsc_black_label/label_types.jsonc b/decompiler/config/jak1_ntsc_black_label/label_types.jsonc index 76eba74bb..e2eae9b9e 100644 --- a/decompiler/config/jak1_ntsc_black_label/label_types.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/label_types.jsonc @@ -432,5 +432,9 @@ ["L28", "level-load-info", true], ["L544", "level-load-info", true], ["L2", "pair", true] + ], + + "load-dgo": [ + ["L46", "uint64", true] ] } diff --git a/decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc b/decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc index 6b2d6aa36..58a158a9e 100644 --- a/decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/stack_vars.jsonc @@ -237,5 +237,9 @@ [144, "vector4s-3"], [192, "vector"], [208, "vector4s-3"] + ], + + "string->sound-name": [ + [16, "qword"] ] } diff --git a/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc b/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc index fc749424d..27caefe7e 100644 --- a/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc @@ -394,5 +394,57 @@ "(method 0 align-control)": [ [[8, 13], "t9", "(function object object)"], [14, "v0", "align-control"] + ], + + "str-load": [ + [[20, 36], "s2", "load-chunk-msg"] + ], + + "str-load-status":[ + [[18, 28], "v1", "load-chunk-msg"] + ], + + "str-play-async": [ + [[8, 16], "s4", "load-chunk-msg"] + ], + + "str-play-stop": [ + [[7, 14], "s5", "load-chunk-msg"] + ], + + "str-play-queue": [ + [[19, 27], "s5", "load-chunk-msg"] + ], + + "str-ambient-play": [ + [[7, 15], "s5", "load-chunk-msg"] + ], + + "str-ambient-stop": [ + [[7, 16], "s5", "load-chunk-msg"] + ], + + "dgo-load-begin": [ + [[21, 40], "s2", "load-dgo-msg"] + ], + + "dgo-load-get-next": [ + [[14, 31], "v1", "load-dgo-msg"] + ], + + "dgo-load-continue": [ + [[5, 21], "gp", "load-dgo-msg"] + ], + + "string->sound-name": [ + [[6, 8], "a1", "(pointer uint8)"] + ], + + "ramdisk-load": [ + [[8, 12], "v1", "ramdisk-rpc-load"] + ], + + "(method 3 generic-tie-interp-point)": [ + [15, "gp", "(pointer uint128)"] ] } diff --git a/decompiler/config/jak1_ntsc_black_label/var_names.jsonc b/decompiler/config/jak1_ntsc_black_label/var_names.jsonc index 15ec59bb4..83576fc71 100644 --- a/decompiler/config/jak1_ntsc_black_label/var_names.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/var_names.jsonc @@ -1579,5 +1579,84 @@ "(method 0 align-control)": { "vars":{"v0-0": ["obj", "align-control"]} + }, + + "str-load": { + "args":["name", "chunk-id", "address", "len"], + "vars":{"s2-0":["cmd", "load-chunk-msg"]} + }, + + "str-load-status": { + "args":["length-out"], + "vars":{"v1-7":"response"} + }, + + "str-play-async": { + "args": ["name", "addr"], + "vars":{"s4-0":"cmd"} + }, + + "str-play-stop": { + "args": ["name"], + "vars":{"s5-0":"cmd"} + }, + + "str-play-queue": { + "args": ["name"], + "vars":{"s5-0":"cmd"} + }, + + "str-ambient-play": { + "args": ["name"], + "vars":{"s5-0":"cmd"} + }, + + "str-ambient-stop": { + "args": ["name"], + "vars":{"s5-0":"cmd"} + }, + + "string->sound-name": { + "args":["str"], + "vars":{"v1-0":"snd-name", "a1-0":["out-ptr", "(pointer uint8)"], "a2-0":"in-ptr"} + }, + "dgo-load-begin": { + "args":["name", "buffer1", "buffer2", "current-heap"], + "vars":{"s2-0":"cmd"} + }, + + "dgo-load-get-next": { + "args":["last-object"], + "vars":{"gp-0":["load-location", "pointer"], "v1-5":"response"} + }, + + "dgo-load-continue": { + "args":["current-heap"], + "vars":{"gp-0":"cmd"} + }, + "dgo-load-cancel": { + "vars":{"a2-0":"cmd"} + }, + + "find-temp-buffer": { + "args":["size"], + "vars":{"gp-0":"qwc"} + }, + + "dgo-load-link": { + "args":["obj-file", "heap", "print-login", "last-object"], + "vars":{"s4-0":"obj-data"} + }, + + "ramdisk-load": { + "args":["file-id", "offset", "length", "buffer"], + "vars":{"v1-1":"cmd"} + }, + + "show-mc-info": { + "args":["dma-buf"], + "vars":{"s5-0":"info", "s4-0":"slot-idx"} } + + } diff --git a/game/kernel/kscheme.cpp b/game/kernel/kscheme.cpp index 952cd9db4..d2f8aa42f 100644 --- a/game/kernel/kscheme.cpp +++ b/game/kernel/kscheme.cpp @@ -222,8 +222,8 @@ u64 new_structure(u32 heap, u32 type) { /*! * Allocate a structure with a dynamic size */ -u64 new_dynamic_structure(u32 heap, u32 type, u32 size) { - return alloc_from_heap(heap, type, size); +u64 new_dynamic_structure(u32 heap_symbol, u32 type, u32 size) { + return alloc_from_heap(heap_symbol, type, size); } /*! diff --git a/goal_src/engine/data/art-h.gc b/goal_src/engine/data/art-h.gc index cc1cd23a8..ad3943e10 100644 --- a/goal_src/engine/data/art-h.gc +++ b/goal_src/engine/data/art-h.gc @@ -59,20 +59,15 @@ ) ) -(defmethod - new - joint-anim-frame - ((allocation symbol) (type-to-make type) (arg0 int)) +(defmethod new joint-anim-frame ((allocation symbol) (type-to-make type) (arg0 int)) (let ((v1-1 (max 0 (+ arg0 -2)))) - (the-as - joint-anim-frame - (new-dynamic-structure - (the-as kheap allocation) - type-to-make - (the-as int (+ (-> type-to-make size) (the-as uint (* 48 v1-1)))) - ) + (the-as joint-anim-frame + (new-dynamic-structure + allocation + type-to-make + (the-as int (+ (-> type-to-make size) (the-as uint (* 48 v1-1))))) + ) ) - ) ) (deftype joint-anim-compressed-hdr (structure) diff --git a/goal_src/engine/gfx/time-of-day-h.gc b/goal_src/engine/gfx/time-of-day-h.gc index 1500cccd9..68cd666f1 100644 --- a/goal_src/engine/gfx/time-of-day-h.gc +++ b/goal_src/engine/gfx/time-of-day-h.gc @@ -28,12 +28,8 @@ ) ) -(define-extern *palette-fade-controls* palette-fade-controls) -(if (or (not *palette-fade-controls*) (zero? *palette-fade-controls*)) - (set! - *palette-fade-controls* - (the-as palette-fade-controls (new 'global 'palette-fade-controls)) - ) +(define-perm *palette-fade-controls* palette-fade-controls + (new 'global 'palette-fade-controls) ) (deftype time-of-day-proc (process) diff --git a/goal_src/engine/load/load-dgo.gc b/goal_src/engine/load/load-dgo.gc index 144f7ed67..faf1dd9f4 100644 --- a/goal_src/engine/load/load-dgo.gc +++ b/goal_src/engine/load/load-dgo.gc @@ -5,15 +5,33 @@ ;; name in dgo: load-dgo ;; dgos: GAME, ENGINE + +;;;;;;;;;;;;;;;;;;;;;;;; +;; OVERLORD messages +;;;;;;;;;;;;;;;;;;;;;;;; + +;; status flag sent from OVERLORD about a DGO load. +(defenum load-msg-result + :type uint16 + :bitfield #f + (done 0) ;; dgo fully loaded! + (error 1) ;; loading failed (file not found, etc) + (more 2) ;; more files exist! + (aborted 3) ;; status returned after a request to cancel. + (invalid 666) ;; invalid status indicating a communication error. + ) + +;; load command sent to the IOP to load a DGO. +;; The OVERLORD responds with the same message. (deftype load-dgo-msg (structure) - ((rsvd uint16 :offset-assert 0) - (result uint16 :offset-assert 2) - (b1 uint32 :offset-assert 4) - (b2 uint32 :offset-assert 8) - (bt uint32 :offset-assert 12) - ;(name uint128 :offset-assert 16) - (name uint8 16 :offset-assert 16) - (address uint32 :offset 4) + ((rsvd uint16 :offset-assert 0) ;; unused? + (result load-msg-result :offset-assert 2) ;; status from OVERLORD + (b1 uint32 :offset-assert 4) ;; EE -> OVERLORD, first temp load buffer + (b2 uint32 :offset-assert 8) ;; EE -> OVERLORD, second temp load buffer + (bt uint32 :offset-assert 12) ;; EE -> OVERLORD, location of heap + (name uint128 :offset-assert 16) ;; EE -> OVERLORD, name of file. + (name-chars uint8 16 :offset 16) ;; name of file (as chars) + (address uint32 :offset 4) ;; OVERLORD -> EE, location of loaded file. ) :method-count-assert 9 :size-assert #x20 @@ -31,14 +49,16 @@ struct RPC_Dgo_Cmd { }; |# +;; load commmand/response for loading a chunk of a file. +;; It can either be an entire file, or a section of a STR file. (deftype load-chunk-msg (structure) - ((rsvd uint16 :offset-assert 0) - (result uint16 :offset-assert 2) - (address pointer :offset-assert 4) - (section uint32 :offset-assert 8) - (maxlen uint32 :offset-assert 12) - (id uint32 :offset 4) - (basename uint8 48 :offset-assert 16) + ((rsvd uint16 :offset-assert 0) ;; unused? + (result load-msg-result :offset-assert 2) ;; only done or error. + (address pointer :offset-assert 4) ;; where to load to + (section uint32 :offset-assert 8) ;; chunk ID, or -1 for the whole file. + (maxlen uint32 :offset-assert 12) ;; maximum length to load. + (id uint32 :offset 4) ;; ? same as chunk + (basename uint8 48 :offset-assert 16) ;; name of file to load. ) :method-count-assert 9 :size-assert #x40 @@ -57,9 +77,12 @@ struct RPC_Str_Cmd { }; |# +;; The header of a DGO file (deftype dgo-header (structure) - ((length uint32 :offset-assert 0) + ((length uint32 :offset-assert 0) ;; number of object files contained. (rootname uint8 60 :offset-assert 4) + ;; added data field + (data uint8 :dynamic :offset-assert 64) ) :method-count-assert 9 :size-assert #x40 @@ -73,38 +96,52 @@ struct DgoHeader { }; |# + +;;;;;;;;;;;;;;;;;;;;;;;;; +;; RPC Buffer init +;;;;;;;;;;;;;;;;;;;;;;;;; + (define-extern *load-dgo-rpc* rpc-buffer-pair) (when (= 0 (the int *load-dgo-rpc*)) ;; we need to allocate the rpc buffers (set! *load-dgo-rpc* (new 'global 'rpc-buffer-pair (the uint 32) (the uint 1) 3)) ;; todo, constants (define *load-str-rpc* (new 'global 'rpc-buffer-pair (the uint 64) (the uint 1) 4)) ;; todo, constants (define *play-str-rpc* (new 'global 'rpc-buffer-pair (the uint 64) (the uint 2) 5)) + + ;; we have separate locks for queuing and loading. (define *load-str-lock* '#f) (define *que-str-lock* '#f) (define *dgo-name* (new 'global 'string 64 (the string '#f))) ) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; STR LOAD +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; load a file, or part of a chunked STR file. + (defun str-load ((name string) (chunk-id int) (address pointer) (len int)) "Begin a streaming load if possible! We must be able to grab the lock, and no streaming load in progress. Return if we actually start the load." - ;; call method 13 - (when (or (check-busy *load-str-rpc*) - *load-str-lock* - ) - (return-from #f '#f) - ) + + ;; check if safe to begin load. + (when (or (check-busy *load-str-rpc*) *load-str-lock*) + (return #f) + ) ;; ok, we are good to start a load. begin by adding an element to the RPC buffer (let ((cmd (the load-chunk-msg (add-element *load-str-rpc*)))) - (set! (-> cmd result) 666) + (set! (-> cmd result) (load-msg-result invalid)) (set! (-> cmd address) address) (set! (-> cmd section) chunk-id) (set! (-> cmd maxlen) len) (charp<-string (-> cmd basename) name) + ;; and then calling with this element (call *load-str-rpc* (the uint 0) (the pointer cmd) (the uint 32)) - (set! *load-str-lock* '#t) - (set! *que-str-lock* '#t) - '#t + (set! *load-str-lock* #t) + (set! *que-str-lock* #t) + #t ) ) @@ -114,21 +151,313 @@ struct DgoHeader { The 'error status indicates the load failed. The 'complete status means the load is finished, and length-out contains the loaded length." - ;; still going.. - (if (check-busy *load-str-rpc*) - (return-from #f 'busy) - ) + ;; still going.. + (if (check-busy *load-str-rpc*) + (return 'busy) + ) - ;; not busy, we can free the lock - (set! *load-str-lock* '#f) - (set! *que-str-lock* '#t) - ;; grab the response - (let ((response (the load-chunk-msg (pop-last-received *load-str-rpc*)))) - (if (= 1 (-> response result)) - (return-from #f 'error) - ) - ;; no error! - (set! (-> length-out) (the int (-> response maxlen))) - 'complete + ;; not busy, we can free the lock + (set! *load-str-lock* #f) + ;; also lock the queue. Not sure why? + (set! *que-str-lock* #t) + ;; grab the response + (let ((response (the load-chunk-msg (pop-last-received *load-str-rpc*)))) + (if (= (-> response result) (load-msg-result error)) + (return 'error) + ) + ;; no error! + (set! (-> length-out) (the int (-> response maxlen))) + 'complete + ) + ) + +(defun str-load-cancel () + "Cancel a str load. This doesn't actually tell the OVERLORD to stop, it just frees the lock." + (set! *load-str-lock* #f) + ;; and locks the queue? + (set! *que-str-lock* #t) + (none) + ) + +;;;;;;;;;;;;;;;;;;;;;;;;; +;; STR PLAY +;;;;;;;;;;;;;;;;;;;;;;;;; + +;; unknown. I think related to playing cutscene stuff? + +(defun str-play-async ((name string) (addr pointer)) + "Queue a play cmd to do... something? + Locks the queue, doesn't check other locks" + (set! *que-str-lock* #t) + (let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*)))) + (charp<-string (-> cmd basename) name) + ;; might be an id? + (set! (-> cmd address) addr) + ;; probably using a different enum here + (set! (-> cmd result) (load-msg-result done)) + ) + (none) + ) + +(defun str-play-stop ((name string)) + "Queue command to stop playing." + (set! *que-str-lock* #t) + (let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*)))) + ;; not sure why we need a name to stop? + (charp<-string (-> cmd basename) name) + ;; might be wrong enum here + (set! (-> cmd result) (load-msg-result error)) + ) + (none) + ) + +(defun str-play-queue ((name string)) + "Queue a command to do something" + (when (and (not (check-busy *play-str-rpc*)) + (not *load-str-lock*) + (not *que-str-lock*) + ) + (let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*)))) + (charp<-string (-> cmd basename) name) + (set! (-> cmd result) (load-msg-result more)) + ) + ) + (set! *que-str-lock* #f) + (none) + ) + +(defun str-ambient-play ((name string)) + "Queue a command to do something" + (set! *que-str-lock* #t) + (let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*)))) + (set! (-> cmd basename 0) (the-as uint 36)) ;; a '$' char + (charp<-string (&-> cmd basename 1) name) + (set! (-> cmd result) (load-msg-result done)) + ) + (none) + ) + +(defun str-ambient-stop ((name string)) + (set! *que-str-lock* #t) + (let ((cmd (the-as load-chunk-msg (add-element *play-str-rpc*)))) + (set! (-> cmd basename 0) (the-as uint 36)) ;; a '$' char + (charp<-string (&-> cmd basename 1) name) + (set! (-> cmd result) (load-msg-result error)) + ) + (none) + ) + +(defun str-play-kick () + "Call str RPC if we aren't busy" + ;; is written with an empty body for the first case. + (cond + ((check-busy *play-str-rpc*) + ) + (else + (call *play-str-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0)) + ) + ) + (none) + ) + + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; DGO LOAD and LINK +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defun string->sound-name! ((out (pointer uint128)) (in string)) + "This function was added as a temporary workaround for not having + uint128 return values in OpenGOAL yet." + (set! (-> out) (the uint128 0)) + (let ((out-ptr (the (pointer uint8) out)) + (in-ptr (-> in data))) + (while (and (nonzero? (-> in-ptr)) + (< (&- in-ptr (-> in data)) 15)) + (set! (-> out-ptr) (-> in-ptr)) + (&+! out-ptr 1) + (&+! in-ptr 1) + ) + ) + ) + +(define *dgo-time* (the-as uint 0)) + +(defun dgo-load-begin ((name string) (buffer1 int) (buffer2 int) (current-heap int)) + "Send a DGO load RPC!" + + ;; remember when we started + (set! *dgo-time* (-> *display* real-integral-frame-counter)) + (format 0 "Starting level load clock~%") + + ;; flush pending RPC + (sync *load-dgo-rpc* #t) + + ;; grab a new command from the RCP buffer + (let ((cmd (the-as load-dgo-msg (add-element *load-dgo-rpc*)))) + ;; set parameters + (set! (-> cmd result) (load-msg-result invalid)) + (set! (-> cmd b1) (the-as uint buffer1)) + (set! (-> cmd b2) (the-as uint buffer2)) + (set! (-> cmd bt) (the-as uint current-heap)) + ;; modified due to OpenGOAL not supporting uint128 return values yet + ;;(set! (-> cmd name) (string->sound-name name)) + (string->sound-name! (&-> cmd name) name) + ;; call now! + (call *load-dgo-rpc* (the-as uint 0) (the-as pointer cmd) (the-as uint 32)) + cmd + ) + ) + +(defun dgo-load-get-next ((last-object (pointer symbol))) + "Check if the currently loading object is done. + Will set the last-object flag depending on if there is more. + Returns #f if it hasn't loaded yet and the address otherwise" + + (set! (-> last-object 0) #t) + (let ((load-location (the-as pointer #f))) + ;; see if RPC is done + (when (not (check-busy *load-dgo-rpc*)) + ;; it is, try to get a response, if there is a new one. + (let ((response (the-as load-dgo-msg (pop-last-received *load-dgo-rpc*)))) + (when response + + ;; get load location + (if (or (= (-> response result) (load-msg-result done)) (= (-> response result) (load-msg-result more))) + ;; success! set load location to the location the IOP loaded to. + (set! load-location (the-as pointer (-> response b1))) + ) + + ;; set more flag + (if (= (-> response result) (load-msg-result more)) + (set! (-> last-object 0) #f) + ) + + ;; if we're done loading, print the load time. + ;; note that this does not include linking/setup of the + ;; final object in the level which may take a significant amount of time + (if (= (-> response result) (load-msg-result done)) + ;; this assumes 60 fps! + (format 0 "Elapsed time for level = ~Fs~%" + (* 0.016666668 (the float (- (-> *display* real-integral-frame-counter) *dgo-time*))) + ) + ) + ) + ) + ) + load-location + ) + ) + +(defun dgo-load-continue ((current-heap pointer)) + "Send a command to to the IOP to continue loading a DGO" + (let ((cmd (the-as load-dgo-msg (add-element *load-dgo-rpc*)))) + (set! (-> cmd result) (load-msg-result invalid)) + (set! (-> cmd b1) (the-as uint 0)) + (set! (-> cmd b2) (the-as uint 0)) + (set! (-> cmd bt) (the-as uint current-heap)) + (set! (-> cmd name) (the-as uint128 0)) + (call *load-dgo-rpc* (the-as uint 1) (the-as pointer cmd) (the-as uint 32)) + (the-as int cmd) + ) + ) + +(defun dgo-load-cancel () + "Send a command to the IOP to cancel loading a DGO. + NOTE: this _might_ stall for a long time (multiple frames) + if you call it while an object is currently being loaded. + I believe this is only good to call if you do it after + dgo-load-get-next and before dgo-load-continue" + (sync *load-dgo-rpc* #t) + (let ((cmd (add-element *load-dgo-rpc*))) + (call *load-dgo-rpc* (the-as uint 2) cmd (the-as uint 32)) + ) + (none) + ) + +(defun find-temp-buffer ((size int)) + "A terrible function to find some temporary space in the DMA system. + It is unused, thankfully" + + ;; it checks the same thing twice. + (let ((qwc (+ (/ size 16) 2))) + (the-as pointer + (cond + ((< (the-as uint qwc) + (the-as uint (dma-buffer-free (-> *display* frames (-> *display* on-screen) frame global-buf))) + ) + (logand -16 (the-as int (&+ (-> *display* frames (-> *display* on-screen) frame global-buf base) 15))) + ) + ((< (the-as uint qwc) + (the-as uint (dma-buffer-free (-> *display* frames (-> *display* on-screen) frame global-buf))) + ) + (logand -16 (the-as int (&+ (-> *display* frames (-> *display* on-screen) frame global-buf base) 15))) + ) + ) + ) + ) + ) + +(defenum link-flag + :bitfield #t + :type int32 + (output-load-msg 0) + (output-load-true-msg 1) + (execute-login 2) + (print-login 3) + (force-debug 4) + (fast-link 5) + ) + +; (link-flag output-load-msg +; output-load-true-msg +; execute-login +; fast-link) + +(defun dgo-load-link ((obj-file dgo-header) (heap kheap) (print-login symbol) (last-object symbol)) + "Begin linking an object from a DGO. + The obj-file argument should be the thing returned from dgo-load-get-next" + (let ((obj-data (-> obj-file data))) + ;; first, check to see if we ran off the end of the heap. + ;; ideally you'd check this _before_ loading the file + (if (>= (the-as int (&+ obj-data (-> obj-file length))) (the-as int (-> heap top-base))) + ;; just print an error, and continue... + (format 0 "ERROR: -----> dgo file header #x~X has overrun heap #x~X by ~D bytes. This is very bad!~%" + obj-file + heap + (&- (&+ obj-data (-> obj-file length)) (the-as uint (-> heap top-base))) + ) + ) + + ;; last object should be loaded on top of the heap. + ;; until this link completes, the heap is in a very strange state. + (if last-object + (format 0 "NOTICE: loaded ~g, ~D bytes (~f K) at top ~D~%" + (-> obj-file rootname) + (-> obj-file length) + (* 0.0009765625 (the float (-> obj-file length))) + (&- (&+ obj-data (-> obj-file length)) (the-as uint (-> heap base))) + ) + ) + + ;; store the dgo name + (string<-charp (clear *dgo-name*) (-> obj-file rootname)) + (nonzero? + (link-begin obj-data (-> *dgo-name* data) (the-as int (-> obj-file length)) heap + (if print-login + (link-flag output-load-msg output-load-true-msg execute-login fast-link print-login) + (link-flag output-load-msg output-load-true-msg execute-login fast-link) + ) + ) ) - ) \ No newline at end of file + ) + ) + +(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) + ) diff --git a/goal_src/engine/load/ramdisk.gc b/goal_src/engine/load/ramdisk.gc index 3ec72572c..aa5d65284 100644 --- a/goal_src/engine/load/ramdisk.gc +++ b/goal_src/engine/load/ramdisk.gc @@ -5,3 +5,67 @@ ;; name in dgo: ramdisk ;; dgos: GAME, ENGINE +;; see game/overlord/ramdisk.cpp +;; unlike most other loads, ramdisk actually uses the response buffer of the RPC +;; to send the data. + +;; command to load something into the OVERLORD RAMDISK from the DVD +;; use with fno = 1 +(deftype ramdisk-rpc-fill (structure) + ((rsvd1 int32 :offset-assert 0) + (ee-id int32 :offset-assert 4) + (rsvd2 int32 2 :offset-assert 8) + (filename uint128 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; get data in ramdisk on EE. +(deftype ramdisk-rpc-load (structure) + ((rsvd int32 :offset-assert 0) + (ee-id int32 :offset-assert 4) + (offset uint32 :offset-assert 8) + (length uint32 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; load file directly to EE. +;; this seems very similar to some functionality in STR. +(deftype ramdisk-rpc-load-to-ee (structure) + ((rsvd int32 :offset-assert 0) + (addr int32 :offset-assert 4) + (offset int32 :offset-assert 8) + (length int32 :offset-assert 12) + (filename uint128 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; allocate the ramdisk RPC buffer +(define *ramdisk-rpc* (new 'global 'rpc-buffer-pair (the-as uint 32) (the-as uint 1) 2)) + +(define *current-ramdisk-id* 0) + +(defun ramdisk-load ((file-id int) (offset uint) (length uint) (buffer pointer)) + "Helper to grab load from ramdisk to ee" + (let ((cmd (the-as ramdisk-rpc-load (add-element *ramdisk-rpc*)))) + (set! (-> cmd offset) offset) + (set! (-> cmd ee-id) file-id) + (set! (-> cmd length) length) + ) + (call *ramdisk-rpc* (the-as uint 0) buffer length) + 0 + ) + +(defun ramdisk-sync () + "Wait for ramdisk RPC to complete." + (sync *ramdisk-rpc* #t) + (none) + ) diff --git a/goal_src/engine/ps2/memcard-h.gc b/goal_src/engine/ps2/memcard-h.gc index f070f3919..5c5e0aa92 100644 --- a/goal_src/engine/ps2/memcard-h.gc +++ b/goal_src/engine/ps2/memcard-h.gc @@ -63,6 +63,38 @@ v0-0 ) -;; TODO - show-mc-info - failed to decompile -;; WARN: Type Propagation failed: Failed to find a stack variable at offset 16 -;; WARN: Type Propagation failed: Type analysis failed \ No newline at end of file +(defun show-mc-info ((dma-buf dma-buffer)) + "Print mc info to the screen." + (let ((info (new 'stack-no-clear 'mc-slot-info))) + (dotimes (slot-idx 2) + (mc-get-slot-info slot-idx) + (cond + ((zero? (-> info known)) + (format (clear *temp-string*) "SLOT ~D: EXAMINING SLOT~%" slot-idx) + ) + ((zero? (-> info handle)) + (format (clear *temp-string*) "SLOT ~D: NO CARD~%" slot-idx) + ) + ((zero? (-> info formatted)) + (format (clear *temp-string*) "SLOT ~D: CARD [~D] : NOT FORMATTED~%" slot-idx (-> info handle)) + ) + ((zero? (-> info inited)) + (format (clear *temp-string*) "SLOT ~D: CARD [~D] : NO FILE [~D/~D]~%" + slot-idx (-> info handle) (-> info mem-required) (-> info mem-actual)) + ) + (else + (format (clear *temp-string*) "SLOT ~D: CARD [~D] : " slot-idx (-> info handle)) + (format *temp-string* "SAVES ~D ~D ~D ~D : LAST ~D~%" + (-> info file 0 present) + (-> info file 1 present) + (-> info file 2 present) + (-> info file 3 present) + (-> info last-file) + ) + ) + ) + (draw-string-xy *temp-string* dma-buf 32 (+ (* 12 slot-idx) 8) 3 1) + ) + ) + (none) + ) diff --git a/goal_src/kernel-defs.gc b/goal_src/kernel-defs.gc index 723673dcb..abbbbcd6b 100644 --- a/goal_src/kernel-defs.gc +++ b/goal_src/kernel-defs.gc @@ -74,6 +74,18 @@ (top 13) ) +(defenum link-flag + :bitfield #t + :type int32 + (output-load-msg 0) + (output-load-true-msg 1) + (execute-login 2) + (print-login 3) + (force-debug 4) + (fast-link 5) + ) + + (define-extern string->symbol (function string symbol)) (define-extern print (function object object)) (define-extern inspect (function object object)) @@ -83,11 +95,11 @@ (define-extern _format (function _varargs_ object)) (define-extern malloc (function symbol int pointer)) (define-extern kmalloc (function kheap int kmalloc-flags string pointer)) -(define-extern new-dynamic-structure (function kheap type int structure)) +(define-extern new-dynamic-structure (function symbol type int structure)) (define-extern method-set! (function type int function none)) ;; may actually return function. (define-extern link (function pointer pointer int kheap int pointer)) (define-extern dgo-load (function string kheap int int none)) -(define-extern link-begin (function pointer string int kheap int int)) +(define-extern link-begin (function pointer (pointer uint8) int kheap link-flag int)) (define-extern link-resume (function int)) (define-extern mc-run (function none)) ;; mc-format @@ -95,8 +107,11 @@ ;; mc-create-file ;; mc-save ;; mc-load +(declare-type mc-slot-info structure) +(define-extern mc-sync (function int)) +(define-extern mc-get-slot-info (function int mc-slot-info)) + (define-extern mc-check-result (function int)) -;; mc-get-slot-info ;; mc-makefile ;; kset-language diff --git a/test/decompiler/reference/all_forward_declarations.gc b/test/decompiler/reference/all_forward_declarations.gc index 7fe3149c3..79940b971 100644 --- a/test/decompiler/reference/all_forward_declarations.gc +++ b/test/decompiler/reference/all_forward_declarations.gc @@ -482,6 +482,17 @@ :flag-assert #x900000010 ) +(deftype plane (vector) + ((a float :offset 0) + (b float :offset 4) + (c float :offset 8) + (d float :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + (deftype attack-info (structure) ((trans vector :inline :offset-assert 0) (vector vector :inline :offset-assert 16) @@ -589,6 +600,48 @@ (define-extern sprite-distorter-generate-tables (function none)) +(defenum load-msg-result + :type uint16 + :bitfield #f + (done 0) + (error 1) + (more 2) + (aborted 3) + (invalid 666) + ) + +(declare-type rpc-buffer-pair basic) +(define-extern string->sound-name (function string uint128)) +(define-extern *dgo-name* string) +(define-extern *load-dgo-rpc* rpc-buffer-pair) +(define-extern *load-str-rpc* rpc-buffer-pair) +(define-extern *play-str-rpc* rpc-buffer-pair) +(define-extern *load-str-lock* symbol) +(define-extern *que-str-lock* symbol) + +(define-extern get-video-mode (function symbol)) +(define-extern draw-string-xy (function string dma-buffer int int int int none)) +(declare-type game-info basic) +(define-extern *game-info* game-info) + +;; shadow-cpu +(deftype shadow-settings (structure) + ((center vector :inline :offset-assert 0) + (flags int32 :offset 12) + (shadow-dir vector :inline :offset-assert 16) + (dist-to-locus float :offset 28) + (bot-plane plane :inline :offset-assert 32) + (top-plane plane :inline :offset-assert 48) + (fade-dist float :offset-assert 64) + (fade-start float :offset-assert 68) + (dummy-2 int32 :offset-assert 72) + (dummy-3 int32 :offset-assert 76) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + (defmacro init-vf0-vector () "Initializes the VF0 vector which is a constant vector in the VU set to <0,0,0,1>" `(.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0)) diff --git a/test/decompiler/reference/engine/anim/bones-h_REF.gc b/test/decompiler/reference/engine/anim/bones-h_REF.gc new file mode 100644 index 000000000..33e9bef2b --- /dev/null +++ b/test/decompiler/reference/engine/anim/bones-h_REF.gc @@ -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: #~%" (-> obj layout)) + (format #t "~Tbounds: #~%" (-> obj bounds)) + (format #t "~Tlights: #~%" (-> obj lights)) + (format #t "~Tdistance: #~%" (-> obj distance)) + (format #t "~Tnext-tag: #~%" (-> obj next-tag)) + (format #t "~Tdma-buf: ~A~%" (-> obj dma-buf)) + (format #t "~Tsink-group: ~A~%" (-> obj sink-group)) + (format #t "~Tnext-pris: #~%" (-> obj next-pris)) + (format #t "~Tnext-merc: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj work)) + (format #t "~Tbuffer[2] @ #x~X~%" (-> obj buffer)) + (format #t "~Tdma-list: #~%" (-> 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: #~%" (-> obj tag)) + (format #t "~Tsettings: #~%" (-> obj settings)) + (format #t "~Tgeo-ref: #~%" (-> obj geo-ref)) + (format #t "~Tmtx-ref: #~%" (-> obj mtx-ref)) + (format #t "~Tend-tag: #~%" (-> obj end-tag)) + obj + ) + +;; failed to figure out what this is: +(let ((v0-9 0)) + ) + + + + diff --git a/test/decompiler/reference/engine/anim/joint-h_REF.gc b/test/decompiler/reference/engine/anim/joint-h_REF.gc new file mode 100644 index 000000000..cc90ad3e8 --- /dev/null +++ b/test/decompiler/reference/engine/anim/joint-h_REF.gc @@ -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: #~%" (-> 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: #~%" (-> obj fixed)) + (format #t "~Tfixed-qwc: ~D~%" (-> obj fixed-qwc)) + (format #t "~Tframe: #~%" (-> 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: #~%" (-> obj temp-mtx)) + (format #t "~Tjoint-stack: #~%" (-> 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: #~%" + (-> obj jacp-hdr) + ) + (format + #t + "~Tfixed-data: #~%" + (-> 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)) + ) + + + + diff --git a/test/decompiler/reference/engine/data/art-h_REF.gc b/test/decompiler/reference/engine/data/art-h_REF.gc new file mode 100644 index 000000000..7db53386b --- /dev/null +++ b/test/decompiler/reference/engine/data/art-h_REF.gc @@ -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: #~%" (-> 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: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj color-mult)) + (format #t "~Tcolor-emissive: #~%" (-> 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)) + ) + + + + diff --git a/test/decompiler/reference/engine/engine/engine_REF.gc b/test/decompiler/reference/engine/engine/engine_REF.gc new file mode 100644 index 000000000..7ba3bd84d --- /dev/null +++ b/test/decompiler/reference/engine/engine/engine_REF.gc @@ -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)) + ) + + + + diff --git a/test/decompiler/reference/engine/game/game-info-h_REF.gc b/test/decompiler/reference/engine/game/game-info-h_REF.gc new file mode 100644 index 000000000..43d68e25e --- /dev/null +++ b/test/decompiler/reference/engine/game/game-info-h_REF.gc @@ -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 + ) + ) + + + + diff --git a/test/decompiler/reference/engine/gfx/generic/generic-vu1-h_REF.gc b/test/decompiler/reference/engine/gfx/generic/generic-vu1-h_REF.gc new file mode 100644 index 000000000..d22c00861 --- /dev/null +++ b/test/decompiler/reference/engine/gfx/generic/generic-vu1-h_REF.gc @@ -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: #~%" (-> obj data)) + (format #t "~Tn-mtx: #~%" (&-> obj data 16)) + (format #t "~Tscale: #~%" (&-> 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: #~%" (-> obj loc-mtx)) + (format #t "~Tpar-mtx: #~%" (-> obj par-mtx)) + (format #t "~Tdif-mtx: #~%" (-> 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: #~%" (-> obj fog)) + (format #t "~Tadgif: #~%" (-> obj adgif)) + (format #t "~Tgiftag: #~%" (-> obj giftag)) + (format #t "~Thvdf-offset: #~%" (-> obj hvdf-offset)) + (format #t "~Thmge-scale: #~%" (-> obj hmge-scale)) + (format #t "~Tinvh-scale: #~%" (-> obj invh-scale)) + (format #t "~Tguard: #~%" (-> obj guard)) + (format #t "~Tadnop: #~%" (-> obj adnop)) + (format #t "~Tflush: #~%" (-> obj flush)) + (format #t "~Tstores: #~%" (-> obj stores)) + obj + ) + +;; failed to figure out what this is: +(let ((v0-3 0)) + ) + + + + diff --git a/test/decompiler/reference/engine/gfx/generic/generic-work-h_REF.gc b/test/decompiler/reference/engine/gfx/generic/generic-work-h_REF.gc new file mode 100644 index 000000000..f5a8088bb --- /dev/null +++ b/test/decompiler/reference/engine/gfx/generic/generic-work-h_REF.gc @@ -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: #~%" (-> obj merc)) + (format #t "~Ttie: #~%" (-> 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: #~%" (-> obj matrix)) + (format #t "~Tstrgif: #~%" (-> obj strgif)) + (format #t "~Tadcmds[2] @ #x~X~%" (-> obj adnop1)) + (format #t "~Tadnop1: #~%" (-> obj adnop1)) + (format #t "~Tadnop2: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj tag)) + (format #t "~Theader: #~%" (-> 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: #~%" (-> obj consts)) + (format #t "~Tstorage: #~%" (-> obj storage)) + (format #t "~Tstorage2: #~%" (-> obj storage2)) + (format #t "~Tlights: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj saves)) + (format #t "~Tstorage: #~%" (-> obj storage)) + (format #t "~Tin-buf: #~%" (-> obj in-buf)) + (format #t "~Tfx-buf: #~%" (-> 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)) + ) + + + + diff --git a/test/decompiler/reference/engine/gfx/hw/display_REF.gc b/test/decompiler/reference/engine/gfx/hw/display_REF.gc index d71c781fb..d23a3c04b 100644 --- a/test/decompiler/reference/engine/gfx/hw/display_REF.gc +++ b/test/decompiler/reference/engine/gfx/hw/display_REF.gc @@ -53,7 +53,7 @@ (set! (-> env smode2) (new 'static 'gs-smode2 :int #x1 :ffmd #x1)) (set! (-> env dspfb) - (new 'static 'gs-display-fb :psm psm :fbw (sar width 6) :fbp fbp) + (new 'static 'gs-display-fb :psm psm :fbw (/ width 64) :fbp fbp) ) (set! (-> env display) @@ -61,7 +61,7 @@ :dw #x9ff :dy (+ dy 50) :dx (+ (* dx (/ 2560 width)) 652) - :dh (+ (shl height 1) -1) + :dh (+ (* height 2) -1) :magh (+ (/ (+ width 2559) width) -1) ) ) @@ -83,7 +83,7 @@ (set! (-> env frame1addr) (gs-reg64 frame-1)) (set! (-> env frame1) - (new 'static 'gs-frame :fbw (sar width 6) :psm (logand psm 15) :fbp fbp) + (new 'static 'gs-frame :fbw (/ width 64) :psm (logand psm 15) :fbp fbp) ) (set! (-> env dtheaddr) (gs-reg64 dthe)) (cond @@ -121,7 +121,7 @@ (-> env xyoffset1) (new 'static 'gs-xy-offset :ofx #x7000 - :ofy (shl (-> *video-parms* screen-miny) 4) + :ofy (* (-> *video-parms* screen-miny) 16) ) ) (set! (-> env scissor1addr) (gs-reg64 scissor-1)) @@ -141,8 +141,8 @@ (set! (-> env xyoffset1) (new 'static 'gs-xy-offset - :ofx (shl (- x (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scax1)) (the-as uint 1))) 1))) 4) - :ofy (+ (shl (- y (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scay1)) (the-as uint 1))) 1))) 4) (if (zero? arg3) 0 8)) + :ofx (* (- x (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scax1)) (the-as uint 1))) 1))) 16) + :ofy (+ (* (- y (the-as int (shr (the-as int (+ (the-as uint (-> env scissor1 scay1)) (the-as uint 1))) 1))) 16) (if (zero? arg3) 0 8)) ) ) env @@ -283,7 +283,7 @@ ;; definition for method 11 of type profile-bar (defmethod add-frame profile-bar ((obj profile-bar) (name symbol) (color rgba)) - (if *debug-segment* + (when *debug-segment* (let ((new-frame (-> obj data (-> obj profile-frame-count)))) (set! (-> obj profile-frame-count) (+ (-> obj profile-frame-count) 1)) (set! (-> new-frame name) name) @@ -341,7 +341,7 @@ ) (let ((block-idx 1) (block-count (-> obj profile-frame-count)) - (left (shl *profile-x* 4)) + (left (* *profile-x* 16)) (end-time 0) (worst-time-cache (new 'static 'array uint32 2 #x0 #x0)) ) @@ -355,10 +355,7 @@ ) (set! (-> direct-tag dma) - (new 'static 'dma-tag - :id (dma-tag-id cnt) - :qwc (+ (shl block-count 1) -1) - ) + (new 'static 'dma-tag :id (dma-tag-id cnt) :qwc (+ (* block-count 2) -1)) ) (set! (-> direct-tag vif0) (new 'static 'vif-tag)) (set! @@ -366,7 +363,7 @@ (new 'static 'vif-tag :cmd (vif-cmd direct) :msk #x1 - :imm (+ (shl block-count 1) -1) + :imm (+ (* block-count 2) -1) ) ) (set! (-> t1-0 base) (&+ (the-as pointer direct-tag) 16)) @@ -410,7 +407,7 @@ (-> (the-as (pointer gs-xyzf) t3-8) 2) (new 'static 'gs-xyzf :z #x3fffff - :y (shl (+ *profile-y* screen-y) 4) + :y (* (+ *profile-y* screen-y) 16) :x left ) ) @@ -421,7 +418,7 @@ ) (set! left - (shl + (* (+ *profile-x* (the-as @@ -432,7 +429,7 @@ ) ) ) - 4 + 16 ) ) ) @@ -443,7 +440,7 @@ (-> (the-as (pointer gs-xyzf) t2-8) 0) (new 'static 'gs-xyzf :z #x3fffff - :y (shl (+ (+ *profile-y* screen-y) *profile-h*) 4) + :y (* (+ (+ *profile-y* screen-y) *profile-h*) 16) :x left ) ) @@ -573,21 +570,21 @@ ) (set! (-> (the-as (pointer gs-xyzf) gif-buf) 2) - (new 'static 'gs-xyzf :z #x3fffff :y (shl draw-y 4) :x (shl draw-x 4)) + (new 'static 'gs-xyzf :z #x3fffff :y (* draw-y 16) :x (* draw-x 16)) ) (set! (-> (the-as (pointer gs-xyzf) gif-buf) 3) (new 'static 'gs-xyzf :z #x3fffff - :y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4) - :x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4) + :y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16) + :x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16) ) ) (set! (-> a2-4 base) (&+ gif-buf 32)) ) (let ((total-qwc - (sar (&+ (- -16 (the-as int (the-as pointer end-dma))) (-> buf base)) 4) + (/ (&+ (- -16 (the-as int (the-as pointer end-dma))) (-> buf base)) 16) ) ) (cond @@ -676,7 +673,7 @@ ) (set! (-> (the-as (pointer gs-xyzf) gif-buf) 2) - (new 'static 'gs-xyzf :y (shl draw-y 4) :x (shl draw-x 4)) + (new 'static 'gs-xyzf :y (* draw-y 16) :x (* draw-x 16)) ) (set! (-> (the-as (pointer gs-rgbaq) gif-buf) 3) @@ -685,8 +682,8 @@ (set! (-> (the-as (pointer gs-xyzf) gif-buf) 4) (new 'static 'gs-xyzf - :y (shl draw-y 4) - :x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4) + :y (* draw-y 16) + :x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16) ) ) (set! @@ -696,8 +693,8 @@ (set! (-> (the-as (pointer gs-xyzf) gif-buf) 6) (new 'static 'gs-xyzf - :y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4) - :x (shl draw-x 4) + :y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16) + :x (* draw-x 16) ) ) (set! @@ -707,14 +704,14 @@ (set! (-> (the-as (pointer gs-xyzf) gif-buf) 8) (new 'static 'gs-xyzf - :y (shl (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 4) - :x (shl (max 1792 (min 2304 (+ draw-x draw-w))) 4) + :y (* (max (min (+ draw-y draw-h) (-> *video-parms* screen-maxy)) (-> *video-parms* screen-miny)) 16) + :x (* (max 1792 (min 2304 (+ draw-x draw-w))) 16) ) ) (set! (-> (the-as (pointer uint64) gif-buf) 9) (the-as uint 0)) (set! (-> t0-2 base) (&+ gif-buf 80)) ) - (let ((total-qwc (sar (&+ (- -16 (the-as int end-dma)) (-> buf base)) 4))) + (let ((total-qwc (/ (&+ (- -16 (the-as int end-dma)) (-> buf base)) 16))) (cond ((nonzero? total-qwc) (set! @@ -794,7 +791,7 @@ (defun set-display-gs-state ((dma-buf dma-buffer) (fbp int) (scx int) (scy int) (fb-msk int) (psm int)) - (let ((fbw (sar (+ scx 63) 6))) + (let ((fbw (/ (+ scx 63) 64))) (let* ((v1-1 dma-buf) (dma (the-as dma-packet (-> v1-1 base))) ) @@ -886,7 +883,7 @@ (off-x int) (off-y int) ) - (let ((fbw (sar (+ width 63) 6))) + (let ((fbw (/ (+ width 63) 64))) (let* ((v1-1 dma-buf) (dma (the-as dma-packet (-> v1-1 base))) ) @@ -935,7 +932,7 @@ (set! (-> (the-as (pointer gs-reg64) gif-data) 1) (gs-reg64 scissor-1)) (set! (-> (the-as (pointer gs-xy-offset) gif-data) 2) - (new 'static 'gs-xy-offset :ofx (shl off-x 4) :ofy (shl off-y 4)) + (new 'static 'gs-xy-offset :ofx (* off-x 16) :ofy (* off-y 16)) ) (set! (-> (the-as (pointer gs-reg64) gif-data) 3) (gs-reg64 xyoffset-1)) (set! @@ -970,7 +967,7 @@ ;; INFO: Return type mismatch display vs none. (defun reset-display-gs-state ((disp display) (dma-buf dma-buffer) (oddeven int)) (let* ((onscreen (-> disp on-screen)) - (hoff (shl oddeven 3)) + (hoff (* oddeven 8)) (fbp (-> disp frames onscreen draw frame1 fbp)) ) (let* ((a3-1 dma-buf) @@ -1024,7 +1021,7 @@ (-> (the-as (pointer gs-xy-offset) gif-data) 2) (new 'static 'gs-xy-offset :ofx #x7000 - :ofy (+ (shl (-> *video-parms* screen-miny) 4) hoff) + :ofy (+ (* (-> *video-parms* screen-miny) 16) hoff) ) ) (set! (-> (the-as (pointer gs-reg64) gif-data) 3) (gs-reg64 xyoffset-1)) @@ -1064,7 +1061,3 @@ ;; failed to figure out what this is: (allocate-dma-buffers *display*) - - - - diff --git a/test/decompiler/reference/engine/gfx/merc/generic-merc-h_REF.gc b/test/decompiler/reference/engine/gfx/merc/generic-merc-h_REF.gc new file mode 100644 index 000000000..b46df432e --- /dev/null +++ b/test/decompiler/reference/engine/gfx/merc/generic-merc-h_REF.gc @@ -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: #~%" (-> obj tag)) + (format #t "~Tlights: #~%" (-> obj lights)) + (format #t "~Theader: #~%" (-> obj header)) + (format #t "~Teffect: #~%" (-> 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: #~%" (-> obj tag)) + (format #t "~Tlights: #~%" (-> obj lights)) + (format #t "~Theader: #~%" (-> obj header)) + (format #t "~Teffect: #~%" (-> 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: #~%" (-> obj geo-tag)) + (format #t "~Tgeo-block[1296] @ #x~X~%" (-> obj geo-block)) + (format #t "~Tbyte-header: #~%" (-> obj geo-block)) + (format #t "~Tmatrix[9] @ #x~X~%" (-> obj matrix)) + (format + #t + "~Tcontrol: #~%" + (-> obj control) + ) + (format #t "~Tend-tag: #~%" (-> obj end-tag)) + (format #t "~Tshader: #~%" (-> 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: #~%" (-> obj info)) + (format #t "~Theader: #~%" (-> 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: #~%" (-> obj output-a)) + (format #t "~Toutput-b: #~%" (-> 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: #~%" (-> obj perspective)) + (format #t "~Tisometric: #~%" (-> obj isometric)) + (format #t "~Tinv-camera-rot: #~%" (-> obj inv-camera-rot)) + (format #t "~Tenvmap-shader: #~%" (-> 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: #~%" + (-> obj indexed-input-base) + ) + (format + #t + "~Tother-input-base: #~%" + (-> obj other-input-base) + ) + (format + #t + "~Tindexed-output-base: #~%" + (-> obj indexed-output-base) + ) + (format + #t + "~Tother-output-base: #~%" + (-> obj other-output-base) + ) + (format #t "~Tp-input: #x~X~%" (-> obj p-input)) + (format #t "~Tgsf-buf: #~%" (-> obj gsf-buf)) + (format #t "~Tp-fheader: #~%" (-> 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: #~%" (-> obj hsr-xmult)) + (format #t "~Thsr-ymult: #~%" (-> 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: #~%" (-> obj input-a)) + (format #t "~Tinput-b: #~%" (-> obj input-b)) + (format #t "~Tctrl: #~%" (-> obj ctrl)) + (format #t "~Tshadow: #~%" (-> obj shadow)) + (format #t "~Tstack[16] @ #x~X~%" (-> obj stack)) + obj + ) + +;; failed to figure out what this is: +(let ((v0-9 0)) + ) + + + + diff --git a/test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc b/test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc new file mode 100644 index 000000000..ee54e57b7 --- /dev/null +++ b/test/decompiler/reference/engine/gfx/merc/merc-h_REF.gc @@ -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: #~%" (-> 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: #~%" (-> obj frag-geo)) + (format + #t + "~Tfrag-ctrl: #~%" + (-> obj frag-ctrl) + ) + (format #t "~Tblend-data: #~%" (-> obj blend-data)) + (format #t "~Tblend-ctrl: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj iris-shader)) + (format #t "~Tpupil-shader: #~%" (-> obj pupil-shader)) + (format #t "~Tlid-shader: #~%" (-> 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: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj tri-strip-gif)) + (format #t "~Tad-gif: #~%" (-> obj ad-gif)) + (format #t "~Thvdf-offset: #~%" (-> obj hvdf-offset)) + (format #t "~Tperspective[4] @ #x~X~%" (-> obj perspective)) + (format #t "~Tfog: #~%" (-> 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)) + ) + + + + diff --git a/test/decompiler/reference/engine/gfx/tie/generic-tie-h_REF.gc b/test/decompiler/reference/engine/gfx/tie/generic-tie-h_REF.gc new file mode 100644 index 000000000..d4e4bceea --- /dev/null +++ b/test/decompiler/reference/engine/gfx/tie/generic-tie-h_REF.gc @@ -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: #~%" (-> obj matrix-tag)) + (format #t "~Tmatrix-data[6] @ #x~X~%" (-> obj matrix-data)) + (format #t "~Tindex-tag: #~%" (-> obj index-tag)) + (format #t "~Tindices[224] @ #x~X~%" (-> obj indices)) + (format #t "~Tend-tag: #~%" (-> 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: #~%" (-> obj palette-tag)) + (format #t "~Tpalette[128] @ #x~X~%" (-> obj palette)) + (format #t "~Tmodel-tag: #~%" (-> obj model-tag)) + (format #t "~Tmodel[146] @ #x~X~%" (-> obj model)) + (format #t "~Tmatrix-tag: #~%" (-> obj matrix-tag)) + (format #t "~Tmatrix-data[6] @ #x~X~%" (-> obj matrix-data)) + (format #t "~Tindex-tag: #~%" (-> obj index-tag)) + (format #t "~Tindices[224] @ #x~X~%" (-> obj indices)) + (format #t "~Tend-tag: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj matrix)) + (format #t "~Tmorph: #~%" (-> obj morph)) + (format #t "~Tfog: #~%" (-> 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: #~%" + (-> obj ptr-runctrl) + ) + (format #t "~Tptr-verts: #x~X~%" (-> obj ptr-verts)) + (format + #t + "~Tptr-generic: #~%" + (-> 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: #~%" (-> 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: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj control)) + (format #t "~Tinterp-job: #~%" (-> obj interp-job)) + (format #t "~Tshadow: #~%" (-> obj shadow)) + (format #t "~Tinput-a: #~%" (-> obj input-a)) + (format #t "~Tinput-b: #~%" (-> obj input-b)) + (format #t "~Tinst-buf: #~%" (-> 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)) + ) + + + + diff --git a/test/decompiler/reference/engine/gfx/tie/prototype-h_REF.gc b/test/decompiler/reference/engine/gfx/tie/prototype-h_REF.gc new file mode 100644 index 000000000..8a736beab --- /dev/null +++ b/test/decompiler/reference/engine/gfx/tie/prototype-h_REF.gc @@ -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: #~%" (-> obj dists)) + (format #t "~Trdists: #~%" (-> 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: #~%" (-> obj dists)) + (format #t "~Trdists: #~%" (-> 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: #~%" (-> obj dists)) + (format #t "~Trdists: #~%" (-> 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: #~%" (-> 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: #~%" (-> obj origin)) + (format #t "~Twind-index: ~D~%" (-> obj wind-index)) + obj + ) + +;; failed to figure out what this is: +(let ((v0-8 0)) + ) + + + + diff --git a/test/decompiler/reference/engine/gfx/time-of-day-h_REF.gc b/test/decompiler/reference/engine/gfx/time-of-day-h_REF.gc new file mode 100644 index 000000000..563949fa4 --- /dev/null +++ b/test/decompiler/reference/engine/gfx/time-of-day-h_REF.gc @@ -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: #~%" (-> 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: #~%" (-> obj current-fog)) + (format #t "~Tcurrent-sun: #~%" (-> obj current-sun)) + (format + #t + "~Tcurrent-prt-color: #~%" + (-> obj current-prt-color) + ) + (format #t "~Tcurrent-shadow: #~%" (-> obj current-shadow)) + (format + #t + "~Tcurrent-shadow-color: #~%" + (-> obj current-shadow-color) + ) + (format #t "~Tlight-group[9] @ #x~X~%" (-> obj light-group)) + (format + #t + "~Ttitle-light-group: #~%" + (-> 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)) + ) + + + + diff --git a/test/decompiler/reference/engine/load/load-dgo_REF.gc b/test/decompiler/reference/engine/load/load-dgo_REF.gc new file mode 100644 index 000000000..552fb7b0f --- /dev/null +++ b/test/decompiler/reference/engine/load/load-dgo_REF.gc @@ -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) + ) + + + + diff --git a/test/decompiler/reference/engine/load/ramdisk_REF.gc b/test/decompiler/reference/engine/load/ramdisk_REF.gc new file mode 100644 index 000000000..fc0c693cb --- /dev/null +++ b/test/decompiler/reference/engine/load/ramdisk_REF.gc @@ -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)) + ) + + + + diff --git a/test/decompiler/reference/engine/ps2/memcard-h_REF.gc b/test/decompiler/reference/engine/ps2/memcard-h_REF.gc new file mode 100644 index 000000000..2df83a657 --- /dev/null +++ b/test/decompiler/reference/engine/ps2/memcard-h_REF.gc @@ -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)) + ) + + + + diff --git a/test/decompiler/reference/engine/ps2/rpc-h_REF.gc b/test/decompiler/reference/engine/ps2/rpc-h_REF.gc new file mode 100644 index 000000000..708c1d15d --- /dev/null +++ b/test/decompiler/reference/engine/ps2/rpc-h_REF.gc @@ -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)) + ) + + + + diff --git a/test/offline/offline_test_main.cpp b/test/offline/offline_test_main.cpp index f4f1c0e31..3718d5274 100644 --- a/test/offline/offline_test_main.cpp +++ b/test/offline/offline_test_main.cpp @@ -14,17 +14,14 @@ namespace fs = std::filesystem; namespace { // list of object files to ignore during reference checks -const std::unordered_set g_object_files_to_ignore_ref_checks = { - "pskernel", "geometry", "timer", "texture", - "ocean-tables", "ocean-frames", "time-of-day", "display"}; - -const std::unordered_set g_object_files_to_ignore_decompiling = { - // TODO - not implemented, if you want to ignore decompiling something currently, don't include - // it in the reference folder +const std::unordered_set g_files_to_skip_compiling = { + "timer", // accessing timer regs + "display", // interrupt handlers + "game-info-h", // variable scoped at object file top-level issue. }; // the functions we expect the decompiler to skip -const std::unordered_set expected_skip_in_decompiler = { +const std::unordered_set g_functions_expected_to_reject = { // gcommon "quad-copy!", // asm mempcy // gkernel @@ -70,7 +67,7 @@ const std::unordered_set expected_skip_in_decompiler = { "(method 15 sync-info-paused)", // needs *res-static-buf* }; -const std::unordered_set skip_in_compiling = { +const std::unordered_set g_functions_to_skip_compiling = { /// GCOMMON // these functions are not implemented by the compiler in OpenGOAL, but are in GOAL. "abs", "ash", "min", "max", "lognor", @@ -133,6 +130,9 @@ const std::unordered_set skip_in_compiling = { // bad decisions on float vs int128 "vector-degf", "vector-degmod", "vector-deg-diff", "vector-degi", + // asm + "invalidate-cache-line", + // capture "(method 3 gs-store-image-packet)", // print giftag weirdness @@ -330,8 +330,8 @@ TEST_F(OfflineDecompilation, AsmFunction) { int failed_count = 0; db->for_each_function([&](decompiler::Function& func, int, decompiler::ObjectFileData&) { if (func.suspected_asm) { - if (expected_skip_in_decompiler.find(func.guessed_name.to_string()) == - expected_skip_in_decompiler.end()) { + if (g_functions_expected_to_reject.find(func.guessed_name.to_string()) == + g_functions_expected_to_reject.end()) { lg::error("Function {} was marked as asm, but wasn't expected.", func.guessed_name.to_string()); failed_count++; @@ -458,11 +458,6 @@ void strip_trailing_newlines(std::string& in) { TEST_F(OfflineDecompilation, Reference) { for (auto& file : g_object_files_to_decompile_or_ref_check) { - if (g_object_files_to_ignore_ref_checks.find(file.first) != - g_object_files_to_ignore_ref_checks.end()) { - continue; - } - auto& obj_l = db->obj_files_by_name.at(file.first); ASSERT_EQ(obj_l.size(), 1); @@ -513,8 +508,7 @@ TEST_F(OfflineDecompilation, Compile) { Timer timer; int total_lines = 0; for (auto& file : g_object_files_to_decompile_or_ref_check) { - if (g_object_files_to_ignore_ref_checks.find(file.first) != - g_object_files_to_ignore_ref_checks.end()) { + if (g_files_to_skip_compiling.find(file.first) != g_files_to_skip_compiling.end()) { continue; } @@ -523,7 +517,7 @@ TEST_F(OfflineDecompilation, Compile) { auto& obj_l = db->obj_files_by_name.at(file.first); ASSERT_EQ(obj_l.size(), 1); - std::string src = db->ir2_final_out(obj_l.at(0), skip_in_compiling); + std::string src = db->ir2_final_out(obj_l.at(0), g_functions_to_skip_compiling); total_lines += line_count(src); compiler.run_full_compiler_on_string_no_save(src);