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

[decompile] decomp time-of-day-h, fix mood-h, update sky-h, make art-h almost work (#415)

Browse source 
* [decompiler] make certain floats decompile to constants

* update various types in `mood-h`, `time-of-day-h` and `art-h`

* fix `time-of-day-context`

* add some offline tests

* make `new-dynamic-structure` decompile at least

* formatting

* Update all-types.gc

* Update all-types.gc
This commit is contained in:
ManDude 2021-05-05 02:36:22 +01:00 committed by GitHub
parent 2beaa7a340
commit 8d99bee88c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 1222 additions and 248 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
common/goos/PrettyPrinter.cpp
View file

@ -17,15 +17,21 @@ namespace pretty_print {
namespace {
// the integer representation is used here instead, wouldn't want really long numbers
const std::unordered_set<u32> banned_floats = {};
// print these floats (shown as ints here) as a named constant instead
const std::unordered_map<u32, std::string> const_floats = {{0x40490fda, "PI"},
{0xc0490fda, "MINUS_PI"}};
} // namespace
/*!
* Print a float in a nice representation if possibly, or an exact 32-bit integer constant to
* Print a float in a nice representation if possible, or an exact 32-bit integer constant to
* be reinterpreted.
*/
goos::Object float_representation(float value) {
u32 int_value;
memcpy(&int_value, &value, 4);
if (banned_floats.find(int_value) == banned_floats.end()) {
if (const_floats.find(int_value) != const_floats.end()) {
return pretty_print::to_symbol(const_floats.at(int_value));
} else if (banned_floats.find(int_value) == banned_floats.end()) {
return goos::Object::make_float(value);
} else {
return pretty_print::build_list("the-as", "float", fmt::format("#x{:x}", int_value));

5
common/type_system/TypeSystem.cpp
View file

@ -962,7 +962,7 @@ int TypeSystem::get_size_in_type(const Field& field) const {
if (field.is_inline()) {
if (!allow_inline(field_type)) {
fmt::print(
"[Type System] Attempted to use {} inline, this probably isn't what you wanted.\n",
"[Type System] Attempted to use `{}` inline, this probably isn't what you wanted.\n",
field_type->get_name());
throw std::runtime_error("bad get size in type");
}
@ -982,7 +982,8 @@ int TypeSystem::get_size_in_type(const Field& field) const {
if (field.is_inline()) {
if (!allow_inline(field_type)) {
fmt::print(
"[Type System] Attempted to use {} inline, this probably isn't what you wanted.\n",
"[Type System] Attempted to use `{}` inline, this probably isn't what you wanted. Type "
"may not be defined fully.\n",
field_type->get_name());
throw std::runtime_error("bad get size in type");
}

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

@ -6375,12 +6375,12 @@
(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 UNKNOWN 8 :offset-assert 160)
(times vector 8 :inline :offset 1696)
(sky-times float 8 :offset-assert 1824)
;; (itimes UNKNOWN 4 :offset-assert 1856)
;; (state UNKNOWN 16 :offset-assert 1920)
(num-stars float :offset 1936)
(light-group light-group 8 :inline :offset-assert 160)
(times vector 8 :inline :offset-assert 1696)
(sky-times float 8 :offset-assert 1824)
(itimes vector4w 4 :inline :offset-assert 1856)
(state uint8 16 :offset-assert 1920)
(num-stars float :offset-assert 1936)
)
(:methods
(new (symbol type) _type_ 0)
@ -6456,46 +6456,46 @@
:flag-assert #x900000014
)
; ;; time-of-day-h
; (deftype time-of-day-context (basic)
; ((active-count uint32 :offset-assert 4)
; (interp float :offset-assert 8)
; (current-interp float :offset-assert 12)
; (moods UNKNOWN 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 UNKNOWN 9 :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 UNKNOWN 2 :offset-assert 2096)
; (light-masks-1 UNKNOWN 2 :offset-assert 2098)
; (light-interp UNKNOWN 2 :offset-assert 2100)
; (sky basic :offset-assert 2108)
; (sun-fade float :offset-assert 2112)
; (title-updated basic :offset-assert 2116)
; )
; :method-count-assert 9
; :size-assert #x848
; :flag-assert #x900000848
; )
;; time-of-day-h
(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
)
; ;; time-of-day-h
; (deftype time-of-day-dma (structure)
; ((outa UNKNOWN 256 :offset-assert 0)
; (outb UNKNOWN 256 :offset-assert 1024)
; (banka UNKNOWN 256 :offset-assert 2048)
; (bankb UNKNOWN 256 :offset-assert 3072)
; )
; :method-count-assert 9
; :size-assert #x1000
; :flag-assert #x900001000
; )
;; time-of-day-h
(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
)
;; art-h
(deftype joint-anim (basic)
@ -6508,17 +6508,32 @@
:flag-assert #x90000000c
)
; ;; art-h
; (deftype joint-anim-drawable (joint-anim)
; ((name basic :offset-assert 4)
; (number int16 :offset-assert 8)
; (length int16 :offset-assert 10)
; (data UNKNOWN :dynamic :offset-assert 12)
; )
; :method-count-assert 9
; :size-assert #xc
; :flag-assert #x90000000c
; )
; art-h
(deftype joint-anim-matrix (joint-anim)
((matrix matrix :offset-assert 12)) ;; guess
;; inspect in joint
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
(deftype joint-anim-transformq (joint-anim)
((transformq transformq :offset-assert 12)) ;; guess
;; inspect in joint
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
;; too many basic blocks
)
;; art-h
(deftype joint-anim-drawable (joint-anim)
((data uint32 :inline :dynamic :offset-assert 12) ;; guess
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; art-h
(deftype joint-anim-compressed (joint-anim)
@ -6528,66 +6543,69 @@
:flag-assert #x90000000c
)
; ;; art-h
; (deftype joint-anim-frame (structure)
; ((matrices UNKNOWN 2 :offset-assert 0)
; (data UNKNOWN :dynamic :offset-assert 128)
; )
; :method-count-assert 9
; :size-assert #x80
; :flag-assert #x900000080
; )
;; art-h
(deftype joint-anim-frame (structure)
((matrices matrix 2 :inline :offset-assert 0)
(data uint32 :dynamic :offset-assert 128) ;; guess
)
:method-count-assert 9
:size-assert #x80
:flag-assert #x900000080
(:methods
(new (symbol type int) _type_ 0)
)
)
; ;; art-h
; (deftype joint-anim-compressed-hdr (structure)
; ((control-bits UNKNOWN 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
; )
;; art-h
(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
)
; ;; art-h
; (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 UNKNOWN 133 :offset-assert 80)
; )
; :method-count-assert 9
; :size-assert #x8a0
; :flag-assert #x9000008a0
; )
;; art-h
(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) ;; guess
)
:method-count-assert 9
:size-assert #x8a0
:flag-assert #x9000008a0
)
; ;; art-h
; (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 UNKNOWN 133 :offset-assert 16)
; )
; :method-count-assert 9
; :size-assert #x860
; :flag-assert #x900000860
; )
;; art-h
(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) ;; guess
)
:method-count-assert 9
:size-assert #x860
:flag-assert #x900000860
)
; ;; art-h
; (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 UNKNOWN 1 :offset-assert 16)
; )
; :method-count-assert 9
; :size-assert #x14
; :flag-assert #x900000014
; )
;; art-h
(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) ;; guess
)
:method-count-assert 9
:size-assert #x14
:flag-assert #x900000014
)
;; art-h
(deftype art (basic)
@ -6620,102 +6638,150 @@
)
)
; ;; art-h
; (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 meters :offset-assert 28)
; (mgeo UNKNOWN 4 :offset-assert 32)
; (max-lod int32 :offset-assert 40)
; (lod-dist UNKNOWN 4 :offset-assert 44)
; (longest-edge meters :offset-assert 60)
; (texture-level int8 :offset-assert 64)
; (version int8 :offset-assert 65)
; (shadow int8 :offset-assert 66)
; (sort int8 :offset-assert 67)
; )
; :method-count-assert 9
; :size-assert #x48
; :flag-assert #x900000048
; )
(deftype art-mesh-anim (art-element)
()
:method-count-assert 13
:size-assert #x20
:flag-assert #xd00000020
)
(deftype art-joint-anim (art-element)
((pad2 uint8 16))
;; inspect in join
:method-count-assert 13
:size-assert #x30
:flag-assert #xd00000030
)
(deftype art-group (art)
((pad2 uint8 12))
;; inspect in join
:method-count-assert 15
:size-assert #x20
:flag-assert #xf00000020
(: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)
)
)
(deftype art-mesh-geo (art-element)
()
:method-count-assert 13
:size-assert #x20
:flag-assert #xd00000020
)
(deftype art-joint-geo (art-element)
()
:method-count-assert 13
:size-assert #x20
:flag-assert #xd00000020
)
;; art-h
(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) ;; meters
(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) ;; meters
(texture-level int8 :offset-assert 64)
(version int8 :offset-assert 65)
(shadow int8 :offset-assert 66)
(sort int8 :offset-assert 67)
(_pad uint8 4) ;; what was here?
)
:method-count-assert 9
:size-assert #x48
:flag-assert #x900000048
)
;; art-h
(deftype lod-group (structure)
((geo basic :offset-assert 0)
(dist float :offset-assert 4) ;; meters
)
:pack-me
:method-count-assert 9
:size-assert #x8
:flag-assert #x900000008
)
; ;; art-h
; (deftype lod-set (structure)
; ((lod UNKNOWN 4 :offset-assert 0)
; (max-lod int8 :offset-assert 32)
; )
; :method-count-assert 10
; :size-assert #x21
; :flag-assert #xa00000021
; (:methods
; (dummy-9 () none 9)
; )
; )
;; art-h
(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)
)
)
; ;; art-h
; (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 basic :offset-assert 8)
; (jgeo basic :offset-assert 12)
; (mgeo basic :offset-assert 16)
; (dma-add-func basic :offset-assert 20)
; (skeleton basic :offset-assert 24)
; (lod-set lod-set :inline :offset-assert 28)
; (lod UNKNOWN 4 :offset-assert 28)
; (max-lod int8 :offset-assert 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 meters :offset-assert 68)
; (longest-edge? uint32 :offset-assert 68)
; (light-index uint8 :offset-assert 72)
; (dummy UNKNOWN 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 basic :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 meters :offset-assert 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 () none 9)
; (dummy-10 () none 10)
; (dummy-11 () none 11)
; )
; )
;; art-h
(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) ;; meters
(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) ;; dma-foreground-sink-group?
(process basic :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) ;; meters
(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 9)
(dummy-10 () none 10)
(dummy-11 () none 11)
)
)
;; generic-vu1-h
(deftype pris-mtx (structure)
@ -13152,23 +13218,6 @@
; :flag-assert #x900000508
; )
;; joint
; (deftype joint-anim-matrix (joint-anim)
; ()
; :method-count-assert 9
; :size-assert #x10
; :flag-assert #x900000010
; )
; ;; joint
; (deftype joint-anim-transformq (joint-anim)
; ()
; :method-count-assert 9
; :size-assert #x10
; :flag-assert #x900000010
; ;; too many basic blocks
; )
; ;; joint
; (deftype art-joint-anim (art-element)
; ()
@ -33615,15 +33664,15 @@
;;(define-extern *ocean-wave-frames* object) ;; unknown type
;;(define-extern sky-color-hour object) ;; unknown type
;;(define-extern sky-circle-data object) ;; unknown type
;;(define-extern *sky-drawn* object) ;; unknown type
(define-extern *sky-drawn* symbol) ;; unknown type
;;(define-extern sky-vertex object) ;; unknown type
;;(define-extern sky-sun-data object) ;; unknown type
;;(define-extern sky-color-day object) ;; unknown type
;;(define-extern *cloud-drawn* object) ;; unknown type
(define-extern *cloud-drawn* symbol) ;; unknown type
;;(define-extern sky-tng-data object) ;; unknown type
;;(define-extern sky-orbit object) ;; unknown type
;;(define-extern sky-upload-data object) ;; unknown type
;;(define-extern *sky-parms* object) ;; unknown type
(define-extern *sky-parms* sky-parms) ;; unknown type
;;(define-extern sky-moon-data object) ;; unknown type
(define-extern *sky-upload-data* sky-upload-data) ;; unknown type
;;(define-extern sky-work object) ;; unknown type
@ -33635,10 +33684,9 @@
;;(define-extern mood-sun-table object) ;; unknown type
;;(define-extern mood-lights object) ;; unknown type
;;(define-extern mood-sun object) ;; unknown type
(define-extern time-of-day-context type)
;;(define-extern *time-of-day-context* object) ;; unknown type
(define-extern *time-of-day-context* time-of-day-context) ;; unknown type
;;(define-extern palette-fade-control object) ;; unknown type
;;(define-extern *time-of-day-mode* object) ;; unknown type
(define-extern *time-of-day-mode* int) ;; unknown type
;;(define-extern time-of-day-dma object) ;; unknown type
;;(define-extern palette-fade-controls object) ;; unknown type
(define-extern *palette-fade-controls* palette-fade-controls) ;; unknown type
@ -33664,7 +33712,7 @@
;;(define-extern joint-anim-frame object) ;; unknown type
;;(define-extern joint-anim-transformq object) ;; unknown type
;;(define-extern lod-set object) ;; unknown type
;;(define-extern new-dynamic-structure object) ;; unknown type
(define-extern new-dynamic-structure (function kheap type int structure)) ;; unknown type
;;(define-extern generic-pris-mtx-save object) ;; unknown type
;;(define-extern generic-constants object) ;; unknown type
;;(define-extern pris-mtx object) ;; unknown type

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

@ -303,6 +303,8 @@
],
"mood-h": [["L3", "float", true]],
"time-of-day-h": [["L2", "time-of-day-context", true]],
"merc-h": [
["L4", "float", true],

12
goal_src/engine/gfx/mood-h.gc
View file

@ -76,12 +76,12 @@
(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 UNKNOWN 8 :offset-assert 160)
(times vector 8 :inline :offset 1696)
(sky-times float 8 :offset-assert 1824)
;; (itimes UNKNOWN 4 :offset-assert 1856)
;; (state UNKNOWN 16 :offset-assert 1920)
(num-stars float :offset 1936)
(light-group light-group 8 :inline :offset-assert 160)
(times vector 8 :inline :offset-assert 1696)
(sky-times float 8 :offset-assert 1824)
(itimes vector4w 4 :inline :offset-assert 1856)
(state uint8 16 :offset-assert 1920)
(num-stars float :offset-assert 1936)
)
(:methods
(new (symbol type) _type_ 0)

25
goal_src/engine/gfx/sky/sky-h.gc
View file

@ -118,24 +118,13 @@
(define *sky-upload-data* (new 'global 'sky-upload-data))
;; generate some sky data.
(let ((gp-0 0))
(while (< gp-0 17)
(let* ((f30-0 (+ (the-as float #xc0490fda)
(* (the-as float #x3ec90fda) (the float (logand gp-0 15)))
)
)
(f0-2 (* (the-as float #x400ccccd) (sin-rad f30-0)))
)
(set! (-> *sky-upload-data* circle data gp-0 data 0)
(* (the-as float #x400ccccd) (sin-rad f30-0))
)
(set! (-> *sky-upload-data* circle data gp-0 data 1) (cos-rad f30-0))
(set! (-> *sky-upload-data* circle data gp-0 data 2) 0.000000)
(set! (-> *sky-upload-data* circle data gp-0 data 3) 0.000000)
(+! gp-0 1)
)
)
(dotimes (gp-0 17)
(let ((f30-0 (+ MINUS_PI (* 0.39269906 (the float (logand gp-0 15))))))
(set! (-> *sky-upload-data* circle data gp-0 x) (* 2.2 (sin-rad f30-0)))
(set! (-> *sky-upload-data* circle data gp-0 y) (cos-rad f30-0))
)
(set! (-> *sky-upload-data* circle data gp-0 z) 0.0)
(set! (-> *sky-upload-data* circle data gp-0 w) 0.0)
)
(deftype sky-tng-data (basic)

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

@ -5,3 +5,112 @@
;; name in dgo: time-of-day-h
;; dgos: GAME, ENGINE
(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
)
(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)
)
)
(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))
)
)
(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)
)
:method-count-assert 14
:size-assert #xb8
:flag-assert #xe000000b8
)
(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
)
(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
)
(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
)
(define *time-of-day-mode* 8) ;; flags? enum?
(define *time-of-day-context* (new 'static 'time-of-day-context))

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

@ -138,6 +138,12 @@
(define-extern quaternion-from-two-vectors-max-angle! (function quaternion vector vector float quaternion))
(define-extern vector-xz-length (function vector float))
;; trigonometry
(defconstant PI (the-as float #x40490fda))
(defconstant MINUS_PI (the-as float #xc0490fda))
(define-extern sin-rad (function float float))
(define-extern cos-rad (function float float))
(defmacro .sync.l ()
`(none))

213
test/decompiler/reference/lights-h_REF.gc Normal file
View file

@ -0,0 +1,213 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type vu-lights
(deftype vu-lights (structure)
((direction uint128 3 :offset-assert 0)
(color uint128 3 :offset-assert 48)
(ambient vector :inline :offset-assert 96)
)
:method-count-assert 9
:size-assert #x70
:flag-assert #x900000070
)
;; definition for method 3 of type vu-lights
(defmethod inspect vu-lights ((obj vu-lights))
(format #t "[~8x] ~A~%" obj 'vu-lights)
(format #t "~Tdirection[3] @ #x~X~%" (-> obj direction))
(format #t "~Tcolor[3] @ #x~X~%" (-> obj color))
(format #t "~Tambient: ~`vector`P~%" (-> obj ambient))
obj
)
;; definition of type light
(deftype light (structure)
((direction vector :inline :offset-assert 0)
(color rgbaf :inline :offset-assert 16)
(levels vector :inline :offset-assert 32)
(level float :offset 32)
(sort-level float :offset 36)
)
:method-count-assert 9
:size-assert #x30
:flag-assert #x900000030
)
;; definition for method 3 of type light
(defmethod inspect light ((obj light))
(format #t "[~8x] ~A~%" obj 'light)
(format #t "~Tdirection: #<vector @ #x~X>~%" (-> obj direction))
(format #t "~Tcolor: #<rgbaf @ #x~X>~%" (-> obj color))
(format #t "~Tlevels: #<vector @ #x~X>~%" (-> obj levels))
(format #t "~Tlevel: ~f~%" (-> obj levels x))
(format #t "~Tsort-level: ~f~%" (-> obj levels y))
obj
)
;; definition of type light-ellipse
(deftype light-ellipse (structure)
((matrix matrix :inline :offset-assert 0)
(color rgbaf :inline :offset-assert 64)
(name basic :offset 12)
(decay-start float :offset 28)
(ambient-point-ratio float :offset 44)
(level float :offset 60)
(func-symbol basic :offset 76)
(func basic :offset 76)
)
:method-count-assert 9
:size-assert #x50
:flag-assert #x900000050
)
;; definition for method 3 of type light-ellipse
(defmethod inspect light-ellipse ((obj light-ellipse))
(format #t "[~8x] ~A~%" obj 'light-ellipse)
(format #t "~Tmatrix: #<matrix @ #x~X>~%" (-> obj matrix))
(format #t "~Tcolor: #<rgbaf @ #x~X>~%" (-> obj color))
(format #t "~Tname: ~A~%" (-> obj matrix data 3))
(format #t "~Tdecay-start: ~f~%" (-> obj matrix data 7))
(format #t "~Tambient-point-ratio: ~f~%" (-> obj matrix data 11))
(format #t "~Tlevel: ~f~%" (-> obj matrix data 15))
(format #t "~Tfunc-symbol: ~A~%" (-> obj color w))
(format #t "~Tfunc: ~A~%" (-> obj color w))
obj
)
;; definition of type light-array
(deftype light-array (array)
()
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type light-array
(defmethod inspect light-array ((obj light-array))
(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 light-volume
(deftype light-volume (basic)
((light-array basic :offset-assert 4)
)
:method-count-assert 9
:size-assert #x8
:flag-assert #x900000008
)
;; definition for method 3 of type light-volume
(defmethod inspect light-volume ((obj light-volume))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tlight-array: ~A~%" (-> obj light-array))
obj
)
;; definition of type light-volume-sphere
(deftype light-volume-sphere (light-volume)
((bsphere sphere :inline :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type light-volume-sphere
(defmethod inspect light-volume-sphere ((obj light-volume-sphere))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tlight-array: ~A~%" (-> obj light-array))
(format #t "~Tbsphere: #<sphere @ #x~X>~%" (-> obj bsphere))
obj
)
;; definition of type light-volume-planes
(deftype light-volume-planes (light-volume)
((planes vertical-planes :offset-assert 8)
)
:method-count-assert 9
:size-assert #xc
:flag-assert #x90000000c
)
;; definition for method 3 of type light-volume-planes
(defmethod inspect light-volume-planes ((obj light-volume-planes))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tlight-array: ~A~%" (-> obj light-array))
(format #t "~Tplanes: #<vertical-planes @ #x~X>~%" (-> obj planes))
obj
)
;; definition of type light-volume-array
(deftype light-volume-array (array)
()
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type light-volume-array
(defmethod inspect light-volume-array ((obj light-volume-array))
(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 for method 2 of type light
(defmethod print light ((obj light))
(format
#t
"#<light [~F] ~F ~F ~F "
(-> obj levels x)
(-> obj direction x)
(-> obj direction y)
(-> obj direction z)
)
(format
#t
"~F ~F ~F @ #x~X>"
(-> obj color x)
(-> obj color y)
(-> obj color z)
obj
)
obj
)
;; definition of type light-group
(deftype light-group (structure)
((dir0 light :inline :offset-assert 0)
(dir1 light :inline :offset-assert 48)
(dir2 light :inline :offset-assert 96)
(ambi light :inline :offset-assert 144)
)
:method-count-assert 9
:size-assert #xc0
:flag-assert #x9000000c0
)
;; definition for method 3 of type light-group
(defmethod inspect light-group ((obj light-group))
(format #t "[~8x] ~A~%" obj 'light-group)
(format #t "~Tdir0: ~`light`P~%" (-> obj dir0))
(format #t "~Tdir1: ~`light`P~%" (-> obj dir1))
(format #t "~Tdir2: ~`light`P~%" (-> obj dir2))
(format #t "~Tambi: ~`light`P~%" (-> obj ambi))
obj
)
;; failed to figure out what this is:
(let ((v0-9 0))
)

266
test/decompiler/reference/mood-h_REF.gc Normal file
View file

@ -0,0 +1,266 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type mood-fog
(deftype mood-fog (structure)
((fog-color vector :inline :offset-assert 0)
(fog-dists vector :inline :offset-assert 16)
(fog-start float :offset 16)
(fog-end float :offset 20)
(fog-max float :offset 24)
(fog-min float :offset 28)
(erase-color vector :inline :offset-assert 32)
)
:method-count-assert 9
:size-assert #x30
:flag-assert #x900000030
)
;; definition for method 3 of type mood-fog
(defmethod inspect mood-fog ((obj mood-fog))
(format #t "[~8x] ~A~%" obj 'mood-fog)
(format #t "~Tfog-color: #<vector @ #x~X>~%" (-> obj fog-color))
(format #t "~Tfog-dists: #<vector @ #x~X>~%" (-> obj fog-dists))
(format #t "~Tfog-start: (meters ~m)~%" (-> obj fog-dists x))
(format #t "~Tfog-end: (meters ~m)~%" (-> obj fog-dists y))
(format #t "~Tfog-max: ~f~%" (-> obj fog-dists z))
(format #t "~Tfog-min: ~f~%" (-> obj fog-dists w))
(format #t "~Terase-color: #<vector @ #x~X>~%" (-> obj erase-color))
obj
)
;; definition of type mood-fog-table
(deftype mood-fog-table (structure)
((data mood-fog 8 :inline :offset-assert 0)
)
:method-count-assert 9
:size-assert #x180
:flag-assert #x900000180
)
;; definition for method 3 of type mood-fog-table
(defmethod inspect mood-fog-table ((obj mood-fog-table))
(format #t "[~8x] ~A~%" obj 'mood-fog-table)
(format #t "~Tdata[8] @ #x~X~%" (-> obj data))
obj
)
;; definition of type mood-lights
(deftype mood-lights (structure)
((direction vector :inline :offset-assert 0)
(lgt-color vector :inline :offset-assert 16)
(prt-color vector :inline :offset-assert 32)
(amb-color vector :inline :offset-assert 48)
(shadow vector :inline :offset-assert 64)
)
:method-count-assert 9
:size-assert #x50
:flag-assert #x900000050
)
;; definition for method 3 of type mood-lights
(defmethod inspect mood-lights ((obj mood-lights))
(format #t "[~8x] ~A~%" obj 'mood-lights)
(format #t "~Tdirection: #<vector @ #x~X>~%" (-> obj direction))
(format #t "~Tlgt-color: #<vector @ #x~X>~%" (-> obj lgt-color))
(format #t "~Tprt-color: #<vector @ #x~X>~%" (-> obj prt-color))
(format #t "~Tamb-color: #<vector @ #x~X>~%" (-> obj amb-color))
(format #t "~Tshadow: #<vector @ #x~X>~%" (-> obj shadow))
obj
)
;; definition of type mood-lights-table
(deftype mood-lights-table (structure)
((data mood-lights 8 :inline :offset-assert 0)
)
:method-count-assert 9
:size-assert #x280
:flag-assert #x900000280
)
;; definition for method 3 of type mood-lights-table
(defmethod inspect mood-lights-table ((obj mood-lights-table))
(format #t "[~8x] ~A~%" obj 'mood-lights-table)
(format #t "~Tdata[8] @ #x~X~%" (-> obj data))
obj
)
;; definition of type mood-sun
(deftype mood-sun (structure)
((sun-color vector :inline :offset-assert 0)
(env-color vector :inline :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type mood-sun
(defmethod inspect mood-sun ((obj mood-sun))
(format #t "[~8x] ~A~%" obj 'mood-sun)
(format #t "~Tsun-color: #<vector @ #x~X>~%" (-> obj sun-color))
(format #t "~Tenv-color: #<vector @ #x~X>~%" (-> obj env-color))
obj
)
;; definition of type mood-sun-table
(deftype mood-sun-table (structure)
((data mood-sun 8 :inline :offset-assert 0)
)
:method-count-assert 9
:size-assert #x100
:flag-assert #x900000100
)
;; definition for method 3 of type mood-sun-table
(defmethod inspect mood-sun-table ((obj mood-sun-table))
(format #t "[~8x] ~A~%" obj 'mood-sun-table)
(format #t "~Tdata[8] @ #x~X~%" (-> obj data))
obj
)
;; definition of type mood-context
(deftype mood-context (basic)
((mood-fog-table mood-fog-table :offset-assert 4)
(mood-lights-table mood-lights-table :offset-assert 8)
(mood-sun-table mood-sun-table :offset-assert 12)
(fog-interp sky-color-day :offset-assert 16)
(palette-interp sky-color-day :offset-assert 20)
(sky-texture-interp sky-color-day :offset-assert 24)
(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 8 :inline :offset-assert 160)
(times vector 8 :inline :offset-assert 1696)
(sky-times float 8 :offset-assert 1824)
(itimes vector4w 4 :inline :offset-assert 1856)
(state uint8 16 :offset-assert 1920)
(num-stars float :offset-assert 1936)
)
:method-count-assert 9
:size-assert #x794
:flag-assert #x900000794
(:methods
(new (symbol type) _type_ 0)
)
)
;; definition for method 3 of type mood-context
(defmethod inspect mood-context ((obj mood-context))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format
#t
"~Tmood-fog-table: #<mood-fog-table @ #x~X>~%"
(-> obj mood-fog-table)
)
(format
#t
"~Tmood-lights-table: #<mood-lights-table @ #x~X>~%"
(-> obj mood-lights-table)
)
(format
#t
"~Tmood-sun-table: #<mood-sun-table @ #x~X>~%"
(-> obj mood-sun-table)
)
(format #t "~Tfog-interp: #<sky-color-day @ #x~X>~%" (-> obj fog-interp))
(format
#t
"~Tpalette-interp: #<sky-color-day @ #x~X>~%"
(-> obj palette-interp)
)
(format
#t
"~Tsky-texture-interp: #<sky-color-day @ #x~X>~%"
(-> obj sky-texture-interp)
)
(format #t "~Tcurrent-fog: #<mood-fog @ #x~X>~%" (-> obj current-fog))
(format #t "~Tcurrent-sun: #<mood-sun @ #x~X>~%" (-> obj current-sun))
(format
#t
"~Tcurrent-prt-color: #<vector @ #x~X>~%"
(-> obj current-prt-color)
)
(format #t "~Tcurrent-shadow: #<vector @ #x~X>~%" (-> obj current-shadow))
(format
#t
"~Tcurrent-shadow-color: #<vector @ #x~X>~%"
(-> obj current-shadow-color)
)
(format #t "~Tlight-group[8] @ #x~X~%" (-> obj light-group))
(format #t "~Ttimes[8] @ #x~X~%" (-> obj times))
(format #t "~Tsky-times[8] @ #x~X~%" (-> obj sky-times))
(format #t "~Titimes[4] @ #x~X~%" (-> obj itimes))
(format #t "~Tstate[16] @ #x~X~%" (-> obj state))
(format #t "~Tnum-stars: ~f~%" (-> obj num-stars))
obj
)
;; definition for method 0 of type mood-context
(defmethod new mood-context ((allocation symbol) (type-to-make type))
(let
((v0-0
(object-new allocation type-to-make (the-as int (-> type-to-make size)))
)
)
(let ((v1-2 (-> v0-0 times)))
(set! (-> v1-2 0 x) 1.0)
(set! (-> v1-2 0 y) 1.0)
(set! (-> v1-2 0 z) 1.0)
(set! (-> v1-2 0 w) 0.0)
)
(let ((v1-3 (-> v0-0 times 1)))
(set! (-> v1-3 x) 1.0)
(set! (-> v1-3 y) 1.0)
(set! (-> v1-3 z) 1.0)
(set! (-> v1-3 w) 0.0)
)
(let ((v1-4 (-> v0-0 times 2)))
(set! (-> v1-4 x) 1.0)
(set! (-> v1-4 y) 1.0)
(set! (-> v1-4 z) 1.0)
(set! (-> v1-4 w) 0.0)
)
(let ((v1-5 (-> v0-0 times 3)))
(set! (-> v1-5 x) 1.0)
(set! (-> v1-5 y) 1.0)
(set! (-> v1-5 z) 1.0)
(set! (-> v1-5 w) 0.0)
)
(let ((v1-6 (-> v0-0 times 4)))
(set! (-> v1-6 x) 1.0)
(set! (-> v1-6 y) 1.0)
(set! (-> v1-6 z) 1.0)
(set! (-> v1-6 w) 0.0)
)
(let ((v1-7 (-> v0-0 times 5)))
(set! (-> v1-7 x) 1.0)
(set! (-> v1-7 y) 1.0)
(set! (-> v1-7 z) 1.0)
(set! (-> v1-7 w) 0.0)
)
(let ((v1-8 (-> v0-0 times 6)))
(set! (-> v1-8 x) 1.0)
(set! (-> v1-8 y) 1.0)
(set! (-> v1-8 z) 1.0)
(set! (-> v1-8 w) 0.0)
)
(let ((v1-9 (-> v0-0 times 7)))
(set! (-> v1-9 x) 1.0)
(set! (-> v1-9 y) 1.0)
(set! (-> v1-9 z) 1.0)
(set! (-> v1-9 w) 0.0)
)
v0-0
)
)
;; failed to figure out what this is:
(let ((v0-7 0))
)

326
test/decompiler/reference/sky-h_REF.gc Normal file
View file

@ -0,0 +1,326 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type sky-color-hour
(deftype sky-color-hour (structure)
((snapshot1 int32 :offset-assert 0)
(snapshot2 int32 :offset-assert 4)
(morph-start float :offset-assert 8)
(morph-end float :offset-assert 12)
)
:method-count-assert 9
:size-assert #x10
:flag-assert #x900000010
)
;; definition for method 3 of type sky-color-hour
(defmethod inspect sky-color-hour ((obj sky-color-hour))
(format #t "[~8x] ~A~%" obj 'sky-color-hour)
(format #t "~Tsnapshot1: ~D~%" (-> obj snapshot1))
(format #t "~Tsnapshot2: ~D~%" (-> obj snapshot2))
(format #t "~Tmorph-start: ~f~%" (-> obj morph-start))
(format #t "~Tmorph-end: ~f~%" (-> obj morph-end))
obj
)
;; definition of type sky-color-day
(deftype sky-color-day (structure)
((hour sky-color-hour 24 :inline :offset-assert 0)
)
:method-count-assert 9
:size-assert #x180
:flag-assert #x900000180
)
;; definition for method 3 of type sky-color-day
(defmethod inspect sky-color-day ((obj sky-color-day))
(format #t "[~8x] ~A~%" obj 'sky-color-day)
(format #t "~Thour[24] @ #x~X~%" (-> obj hour))
obj
)
;; definition of type sky-circle-data
(deftype sky-circle-data (structure)
((data vector 17 :inline :offset-assert 0)
)
:method-count-assert 9
:size-assert #x110
:flag-assert #x900000110
)
;; definition for method 3 of type sky-circle-data
(defmethod inspect sky-circle-data ((obj sky-circle-data))
(format #t "[~8x] ~A~%" obj 'sky-circle-data)
(format #t "~Tdata[17] @ #x~X~%" (-> obj data))
obj
)
;; definition of type sky-sun-data
(deftype sky-sun-data (structure)
((data uint128 4 :offset-assert 0)
(pos vector :inline :offset 0)
(r-sun float :offset 16)
(r-halo float :offset 20)
(r-aurora float :offset 24)
(c-sun-start uint32 :offset 32)
(c-sun-end uint32 :offset 48)
(c-halo-start uint32 :offset 36)
(c-halo-end uint32 :offset 52)
(c-aurora-start uint32 :offset 40)
(c-aurora-end uint32 :offset 56)
)
:method-count-assert 9
:size-assert #x40
:flag-assert #x900000040
)
;; definition for method 3 of type sky-sun-data
(defmethod inspect sky-sun-data ((obj sky-sun-data))
(format #t "[~8x] ~A~%" obj 'sky-sun-data)
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
(format #t "~Tpos: #<vector @ #x~X>~%" (-> obj data))
(format #t "~Tr-sun: ~f~%" (-> obj r-sun))
(format #t "~Tr-halo: ~f~%" (-> obj r-halo))
(format #t "~Tr-aurora: ~f~%" (-> obj r-aurora))
(format #t "~Tc-sun-start: ~D~%" (-> obj c-sun-start))
(format #t "~Tc-sun-end: ~D~%" (-> obj c-sun-end))
(format #t "~Tc-halo-start: ~D~%" (-> obj c-halo-start))
(format #t "~Tc-halo-end: ~D~%" (-> obj c-halo-end))
(format #t "~Tc-aurora-start: ~D~%" (-> obj c-aurora-start))
(format #t "~Tc-aurora-end: ~D~%" (-> obj c-aurora-end))
obj
)
;; definition of type sky-moon-data
(deftype sky-moon-data (structure)
((data uint128 2 :offset-assert 0)
(pos vector :inline :offset 0)
(scale vector :inline :offset 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type sky-moon-data
(defmethod inspect sky-moon-data ((obj sky-moon-data))
(format #t "[~8x] ~A~%" obj 'sky-moon-data)
(format #t "~Tdata[2] @ #x~X~%" (-> obj data))
(format #t "~Tpos: #<vector @ #x~X>~%" (-> obj data))
(format #t "~Tscale: #<vector @ #x~X>~%" (&-> obj data 1))
obj
)
;; definition of type sky-orbit
(deftype sky-orbit (structure)
((high-noon float :offset-assert 0)
(tilt float :offset-assert 4)
(rise float :offset-assert 8)
(dist float :offset-assert 12)
(min-halo float :offset-assert 16)
(max-halo float :offset-assert 20)
)
:allow-misaligned :method-count-assert 9
:size-assert #x18
:flag-assert #x900000018
)
;; definition for method 3 of type sky-orbit
(defmethod inspect sky-orbit ((obj sky-orbit))
(format #t "[~8x] ~A~%" obj 'sky-orbit)
(format #t "~Thigh-noon: ~f~%" (-> obj high-noon))
(format #t "~Ttilt: ~f~%" (-> obj tilt))
(format #t "~Trise: ~f~%" (-> obj rise))
(format #t "~Tdist: ~f~%" (-> obj dist))
(format #t "~Tmin-halo: ~f~%" (-> obj min-halo))
(format #t "~Tmax-halo: ~f~%" (-> obj max-halo))
obj
)
;; definition of type sky-upload-data
(deftype sky-upload-data (basic)
((circle sky-circle-data :inline :offset-assert 16)
(sun sky-sun-data 2 :inline :offset-assert 288)
(moon sky-moon-data :inline :offset-assert 416)
(data uint128 27 :offset 16)
)
:method-count-assert 9
:size-assert #x1c0
:flag-assert #x9000001c0
)
;; definition for method 3 of type sky-upload-data
(defmethod inspect sky-upload-data ((obj sky-upload-data))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tdata[27] @ #x~X~%" (-> obj circle))
(format #t "~Tcircle: #<sky-circle-data @ #x~X>~%" (-> obj circle))
(format #t "~Tsun[2] @ #x~X~%" (-> obj sun))
(format #t "~Tmoon: #<sky-moon-data @ #x~X>~%" (-> obj moon))
obj
)
;; definition of type sky-parms
(deftype sky-parms (basic)
((orbit sky-orbit 3 :inline :offset-assert 4)
(upload-data sky-upload-data :inline :offset-assert 112)
(sun-lights light-group :inline :offset-assert 560)
(moon-lights light-group :inline :offset-assert 752)
(default-lights light-group :inline :offset-assert 944)
(default-vu-lights vu-lights :inline :offset-assert 1136)
)
:method-count-assert 9
:size-assert #x4e0
:flag-assert #x9000004e0
(:methods
(new (symbol type) _type_ 0)
)
)
;; definition for method 3 of type sky-parms
(defmethod inspect sky-parms ((obj sky-parms))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Torbit[3] @ #x~X~%" (-> obj orbit))
(format #t "~Tupload-data: #<sky-upload-data @ #x~X>~%" (-> obj upload-data))
(format #t "~Tsun-lights: #<light-group @ #x~X>~%" (-> obj sun-lights))
(format #t "~Tmoon-lights: #<light-group @ #x~X>~%" (-> obj moon-lights))
(format
#t
"~Tdefault-lights: #<light-group @ #x~X>~%"
(-> obj default-lights)
)
(format
#t
"~Tdefault-vu-lights: #<vu-lights @ #x~X>~%"
(-> obj default-vu-lights)
)
obj
)
;; definition for method 0 of type sky-parms
(defmethod new sky-parms ((allocation symbol) (type-to-make type))
(let
((v0-0
(object-new allocation type-to-make (the-as int (-> type-to-make size)))
)
)
(set! (-> v0-0 upload-data type) sky-upload-data)
v0-0
)
)
;; definition for symbol *sky-parms*, type sky-parms
(define *sky-parms* (new 'global 'sky-parms))
;; definition for symbol *sky-upload-data*, type sky-upload-data
(define
*sky-upload-data*
(the-as sky-upload-data (new 'global 'sky-upload-data))
)
;; failed to figure out what this is:
(dotimes (gp-0 17)
(let ((f30-0 (+ MINUS_PI (* 0.39269906 (the float (logand gp-0 15))))))
(set! (-> *sky-upload-data* circle data gp-0 x) (* 2.2 (sin-rad f30-0)))
(set! (-> *sky-upload-data* circle data gp-0 y) (cos-rad f30-0))
)
(set! (-> *sky-upload-data* circle data gp-0 z) 0.0)
(set! (-> *sky-upload-data* circle data gp-0 w) 0.0)
)
;; failed to figure out what this is:
(empty-form)
;; failed to figure out what this is:
(empty-form)
;; definition of type sky-tng-data
(deftype sky-tng-data (basic)
((giftag-base qword :inline :offset-assert 16)
(giftag-roof qword :inline :offset-assert 32)
(giftag-ocean qword :inline :offset-assert 48)
(fog vector :inline :offset-assert 64)
(sky uint32 8 :offset-assert 80)
(time float :offset-assert 112)
(off-s-0 uint16 :offset-assert 116)
(off-t-0 uint16 :offset-assert 118)
(off-s-1 uint16 :offset-assert 120)
(off-t-1 uint16 :offset-assert 122)
)
:method-count-assert 9
:size-assert #x7c
:flag-assert #x90000007c
)
;; definition for method 3 of type sky-tng-data
(defmethod inspect sky-tng-data ((obj sky-tng-data))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tgiftag-base: #<qword @ #x~X>~%" (-> obj giftag-base))
(format #t "~Tgiftag-roof: #<qword @ #x~X>~%" (-> obj giftag-roof))
(format #t "~Tgiftag-ocean: #<qword @ #x~X>~%" (-> obj giftag-ocean))
(format #t "~Tfog: #<vector @ #x~X>~%" (-> obj fog))
(format #t "~Tsky[8] @ #x~X~%" (-> obj sky))
(format #t "~Ttime: ~f~%" (-> obj time))
(format #t "~Toff-s-0: ~D~%" (-> obj off-s-0))
(format #t "~Toff-t-0: ~D~%" (-> obj off-t-0))
(format #t "~Toff-s-1: ~D~%" (-> obj off-s-1))
(format #t "~Toff-t-1: ~D~%" (-> obj off-t-1))
obj
)
;; definition of type sky-work
(deftype sky-work (structure)
((adgif-tmpl dma-gif-packet :inline :offset-assert 0)
(draw-tmpl dma-gif-packet :inline :offset-assert 32)
(blend-tmpl dma-gif-packet :inline :offset-assert 64)
(sky-data uint128 5 :offset-assert 96)
(cloud-data uint128 5 :offset-assert 176)
)
:method-count-assert 9
:size-assert #x100
:flag-assert #x900000100
)
;; definition for method 3 of type sky-work
(defmethod inspect sky-work ((obj sky-work))
(format #t "[~8x] ~A~%" obj 'sky-work)
(format #t "~Tadgif-tmpl: #<dma-gif-packet @ #x~X>~%" (-> obj adgif-tmpl))
(format #t "~Tdraw-tmpl: #<dma-gif-packet @ #x~X>~%" (-> obj draw-tmpl))
(format #t "~Tblend-tmpl: #<dma-gif-packet @ #x~X>~%" (-> obj blend-tmpl))
(format #t "~Tsky-data[5] @ #x~X~%" (-> obj sky-data))
(format #t "~Tcloud-data[5] @ #x~X~%" (-> obj cloud-data))
obj
)
;; definition of type sky-vertex
(deftype sky-vertex (structure)
((pos vector :inline :offset-assert 0)
(stq vector :inline :offset-assert 16)
(col vector :inline :offset-assert 32)
)
:method-count-assert 9
:size-assert #x30
:flag-assert #x900000030
)
;; definition for method 3 of type sky-vertex
(defmethod inspect sky-vertex ((obj sky-vertex))
(format #t "[~8x] ~A~%" obj 'sky-vertex)
(format #t "~Tpos: #<vector @ #x~X>~%" (-> obj pos))
(format #t "~Tstq: #<vector @ #x~X>~%" (-> obj stq))
(format #t "~Tcol: #<vector @ #x~X>~%" (-> obj col))
obj
)
;; definition for symbol *sky-drawn*, type symbol
(define *sky-drawn* #f)
;; definition for symbol *cloud-drawn*, type symbol
(define *cloud-drawn* #f)
;; failed to figure out what this is:
(let ((v0-15 0))
)

8
test/offline/offline_test_main.cpp
View file

@ -22,6 +22,10 @@ const std::unordered_set<std::string> g_object_files_to_decompile = {
/* gap */
"mspace-h", "drawable-h", "drawable-group-h",
/* gap */
"lights-h",
/* gap */
"sky-h", "mood-h", /* "time-of-day-h", */
/* gap */
"bounding-box",
/* gap */
"sync-info-h", "sync-info"};
@ -40,6 +44,10 @@ const std::vector<std::string> g_object_files_to_check_against_reference = {
"display",
/* gap */
"mspace-h", "drawable-h", "drawable-group-h",
/* gap */
"lights-h",
/* gap */
"sky-h", "mood-h", /* "time-of-day-h", */
/* gap */ "bounding-box",
/* gap */
"sync-info-h", "sync-info"};