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

[decomp] gsound (#583)

Browse source
This commit is contained in:
ManDude 2021-06-12 15:48:38 +01:00 committed by GitHub
parent 504a073f8f
commit 877e3d161c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
21 changed files with 1776 additions and 336 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1241,11 +1241,12 @@
) )
(deftype vector3w (structure) (deftype vector3w (structure)
((data int32 3 :offset-assert 0) ((data int32 3 :do-not-decompile :offset-assert 0)
(x int32 :offset 0) (x int32 :offset 0)
(y int32 :offset 4) (y int32 :offset 4)
(z int32 :offset 8) (z int32 :offset 8)
) )
:allow-misaligned
:method-count-assert 9 :method-count-assert 9
:size-assert #xc :size-assert #xc
:flag-assert #x90000000c :flag-assert #x90000000c
@ -2112,13 +2113,42 @@
) )
(deftype sound-name (uint128) (deftype sound-name (uint128)
() ((lo uint64 :offset 0)
(hi uint64 :offset 64)
)
:flag-assert #x900000010 :flag-assert #x900000010
) )
(defenum sound-command
:type uint16
(load-bank)
(load-music)
(unload-bank)
(play)
(pause-sound)
(stop-sound)
(continue-sound)
(set-param)
(set-master-volume)
(pause-group)
(stop-group)
(continue-group)
(get-irx-version)
(set-falloff-curve)
(set-sound-falloff)
(reload-info)
(set-language)
(set-flava)
(set-reverb)
(set-ear-trans)
(shutdown)
(list-sounds)
(unload-music)
)
(deftype sound-rpc-cmd (structure) (deftype sound-rpc-cmd (structure)
((rsvd1 uint16 :offset-assert 0) ((rsvd1 uint16 :offset-assert 0)
(command uint16 :offset-assert 2) (command sound-command :offset-assert 2)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x4 :size-assert #x4
@ -2134,7 +2164,7 @@
(fo-curve int8 :offset-assert 10) (fo-curve int8 :offset-assert 10)
(priority int8 :offset-assert 11) (priority int8 :offset-assert 11)
(volume int32 :offset-assert 12) (volume int32 :offset-assert 12)
(trans float 3 :offset-assert 16) ;; guess on type here (trans vector3w :inline :offset-assert 16)
(group uint8 :offset-assert 28) (group uint8 :offset-assert 28)
) )
:pack-me :pack-me
@ -2144,7 +2174,7 @@
) )
(deftype sound-rpc-bank-cmd (sound-rpc-cmd) (deftype sound-rpc-bank-cmd (sound-rpc-cmd)
((bank-name uint128 :offset-assert 16) ((bank-name sound-name :offset-assert 16)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x20 :size-assert #x20
@ -2152,7 +2182,7 @@
) )
(deftype sound-rpc-sound-cmd (sound-rpc-cmd) (deftype sound-rpc-sound-cmd (sound-rpc-cmd)
((id uint32 :offset-assert 4) ((id sound-id :offset-assert 4)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x8 :size-assert #x8
@ -2189,7 +2219,7 @@
) )
(deftype sound-rpc-play (sound-rpc-sound-cmd) (deftype sound-rpc-play (sound-rpc-sound-cmd)
((name uint128 :offset-assert 16) ((name sound-name :offset-assert 16)
(parms sound-play-parms :inline :offset-assert 32) (parms sound-play-parms :inline :offset-assert 32)
) )
:method-count-assert 9 :method-count-assert 9
@ -2260,7 +2290,7 @@
(deftype sound-rpc-get-irx-version (sound-rpc-cmd) (deftype sound-rpc-get-irx-version (sound-rpc-cmd)
((major uint32 :offset-assert 4) ((major uint32 :offset-assert 4)
(minor uint32 :offset-assert 8) (minor uint32 :offset-assert 8)
(ee-addr uint32 :offset-assert 12) (ee-addr pointer :offset-assert 12)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x10 :size-assert #x10
@ -2286,7 +2316,7 @@
) )
(deftype sound-rpc-set-sound-falloff (sound-rpc-cmd) (deftype sound-rpc-set-sound-falloff (sound-rpc-cmd)
((name uint128 :offset-assert 16) ((name sound-name :offset-assert 16)
(curve int32 :offset-assert 32) (curve int32 :offset-assert 32)
(min int32 :offset-assert 36) (min int32 :offset-assert 36)
(max int32 :offset-assert 40) (max int32 :offset-assert 40)
@ -2315,8 +2345,8 @@
) )
(deftype sound-rpc-set-ear-trans (sound-rpc-cmd) (deftype sound-rpc-set-ear-trans (sound-rpc-cmd)
((ear-trans float 3 :offset-assert 4) ;; guess on float, may be fixed point ((ear-trans vector3w :inline :offset-assert 4)
(cam-trans float 3 :offset-assert 16) (cam-trans vector3w :inline :offset-assert 16)
(cam-angle int32 :offset-assert 28) (cam-angle int32 :offset-assert 28)
) )
:method-count-assert 9 :method-count-assert 9
@ -2388,7 +2418,7 @@
(num float :offset-assert 8) (num float :offset-assert 8)
(group uint8 :offset-assert 12) (group uint8 :offset-assert 12)
(sound-name-char uint8 16 :offset 16) (sound-name-char uint8 16 :offset 16)
(sound-name uint128 :offset 16) (sound-name sound-name :offset 16)
(trans float 4 :offset-assert 32) ;; guess (trans float 4 :offset-assert 32) ;; guess
(volume int32 :offset-assert 48) (volume int32 :offset-assert 48)
(pitch-mod int32 :offset-assert 52) (pitch-mod int32 :offset-assert 52)
@ -2405,33 +2435,35 @@
:flag-assert #x90000004c :flag-assert #x90000004c
) )
(declare-type entity basic)
(deftype ambient-sound (basic) (deftype ambient-sound (basic)
((spec basic :offset-assert 4) ((spec sound-spec :offset-assert 4)
(playing-id uint32 :offset-assert 8) (playing-id sound-id :offset-assert 8)
(trans vector :inline :offset-assert 16) (trans vector :inline :offset-assert 16)
(name uint128 :offset-assert 32) (name sound-name :offset-assert 32)
(play-time uint64 :offset-assert 48) (play-time uint64 :offset-assert 48)
(time-base uint64 :offset-assert 56) (time-base uint64 :offset-assert 56)
(time-random uint64 :offset-assert 64) (time-random uint64 :offset-assert 64)
(volume int32 :offset-assert 72) (volume int32 :offset-assert 72)
(pitch int32 :offset-assert 76) (pitch int32 :offset-assert 76)
(falloff-near int32 :offset-assert 80) (falloff-near int32 :offset-assert 80)
(falloff-far int32 :offset-assert 84) (falloff-far int32 :offset-assert 84)
(falloff-mode int32 :offset-assert 88) (falloff-mode int32 :offset-assert 88)
(params uint32 :offset-assert 92) (params sound-play-parms :offset-assert 92)
(param-count int32 :offset-assert 96) (param-count int32 :offset-assert 96)
(entity basic :offset-assert 100) (entity entity :offset-assert 100)
(sound-count int32 :offset-assert 104) (sound-count int32 :offset-assert 104)
) )
:method-count-assert 14 :method-count-assert 14
:size-assert #x6c :size-assert #x6c
:flag-assert #xe0000006c :flag-assert #xe0000006c
(:methods (:methods
(dummy-9 () none 9) (new (symbol type basic vector) _type_ 0)
(dummy-10 () none 10) (dummy-9 (_type_) int 9)
(dummy-11 () none 11) (dummy-10 (_type_ sound-name) int 10)
(dummy-12 () none 12) (dummy-11 (_type_ vector) int 11)
(dummy-13 () none 13) (dummy-12 (_type_ int) int 12)
(stop! (_type_) int 13)
) )
) )
@ -4998,7 +5030,7 @@
(:methods (:methods
(new (symbol type int) _type_ 0) (new (symbol type int) _type_ 0)
(dummy-9 () none 9) (dummy-9 () none 9)
(dummy-10 () none 10) (dummy-10 (_type_ process symbol symbol float int) none 10)
(dummy-11 () none 11) (dummy-11 () none 11)
(dummy-12 () none 12) (dummy-12 () none 12)
(dummy-13 () none 13) (dummy-13 () none 13)
@ -5624,15 +5656,15 @@
) )
(deftype level-hint (process) (deftype level-hint (process)
((text-id-to-display uint32 :offset-assert 112) ((text-id-to-display uint32 :offset-assert 112)
(sound-to-play basic :offset-assert 116) (sound-to-play basic :offset-assert 116)
(trans vector :offset-assert 120) (trans vector :offset-assert 120)
(sound-id uint32 :offset-assert 124) (sound-id sound-id :offset-assert 124)
(mode basic :offset-assert 128) (mode basic :offset-assert 128)
(total-time uint64 :offset-assert 136) (total-time uint64 :offset-assert 136)
(total-off-time uint64 :offset-assert 144) (total-off-time uint64 :offset-assert 144)
(last-time uint64 :offset-assert 152) (last-time uint64 :offset-assert 152)
(voicebox uint64 :offset-assert 160) (voicebox uint64 :offset-assert 160)
) )
:heap-base #x40 :heap-base #x40
:method-count-assert 16 :method-count-assert 16
@ -11017,7 +11049,7 @@
(update-velocity basic :offset-assert 396) (update-velocity basic :offset-assert 396)
(counter int32 :offset-assert 400) (counter int32 :offset-assert 400)
(target-count int32 :offset-assert 404) (target-count int32 :offset-assert 404)
(sound-id uint32 :offset-assert 408) (sound-id sound-id :offset-assert 408)
) )
:heap-base #x130 :heap-base #x130
:method-count-assert 29 :method-count-assert 29
@ -13708,27 +13740,27 @@
:flag-assert #x900000008 :flag-assert #x900000008
) )
; (deftype task-info-data (basic) (deftype task-info-data (basic)
; ((task-id uint8 :offset-assert 4) ((task-id uint8 :offset-assert 4)
; (task-name UNKNOWN 4 :offset-assert 8) (task-name symbol 4 :offset-assert 8)
; (text-index-when-resolved int32 :offset-assert 24) (text-index-when-resolved int32 :offset-assert 24)
; ) )
; :method-count-assert 9 :method-count-assert 9
; :size-assert #x1c :size-assert #x1c
; :flag-assert #x90000001c :flag-assert #x90000001c
; ) )
; (deftype level-tasks-info (basic) (deftype level-tasks-info (basic)
; ((level-name-id uint32 :offset-assert 4) ((level-name-id uint32 :offset-assert 4)
; (text-group-index int32 :offset-assert 8) (text-group-index int32 :offset-assert 8)
; (nb-of-tasks int32 :offset-assert 12) (nb-of-tasks int32 :offset-assert 12)
; (buzzer-task-index int32 :offset-assert 16) (buzzer-task-index int32 :offset-assert 16)
; (task-info UNKNOWN 8 :offset-assert 20) (task-info task-info-data 8 :offset-assert 20)
; ) )
; :method-count-assert 9 :method-count-assert 9
; :size-assert #x34 :size-assert #x34
; :flag-assert #x900000034 :flag-assert #x900000034
; ) )
(deftype game-option (basic) (deftype game-option (basic)
((option-type uint64 :offset-assert 8) ((option-type uint64 :offset-assert 8)
@ -13790,16 +13822,15 @@
(card-info mc-slot-info :offset-assert 292) (card-info mc-slot-info :offset-assert 292)
(last-option-index-change uint64 :offset-assert 296) (last-option-index-change uint64 :offset-assert 296)
(video-mode-timeout uint64 :offset-assert 304) (video-mode-timeout uint64 :offset-assert 304)
(pad uint8 :offset 731) (display-state-stack uint64 5 :offset-assert 312)
; (display-state-stack UNKNOWN 5 :offset-assert 312) (option-index-stack uint32 5 :offset-assert 352)
; (option-index-stack UNKNOWN 5 :offset-assert 352) (display-state-pos int32 :offset-assert 372)
; (display-state-pos int32 :offset-assert 372) (nb-of-icons int32 :offset-assert 376)
; (nb-of-icons int32 :offset-assert 376) (icons uint32 6 :offset-assert 380)
; (icons UNKNOWN 6 :offset-assert 380) (max-nb-of-particles int32 :offset-assert 404)
; (max-nb-of-particles int32 :offset-assert 404) (nb-of-particles int32 :offset-assert 408)
; (nb-of-particles int32 :offset-assert 408) (particles uint32 40 :offset-assert 412)
; (particles UNKNOWN 40 :offset-assert 412) (particle-state uint32 40 :offset-assert 572)
; (particle-state UNKNOWN 40 :offset-assert 572)
) )
:method-count-assert 59 :method-count-assert 59
:size-assert #x2dc :size-assert #x2dc
@ -13856,11 +13887,11 @@
;; - Symbols ;; - Symbols
(define-extern *progress-process* process) ;; unknown type (define-extern *progress-process* (pointer progress))
;; - Unknowns ;; - Unknowns
;;(define-extern *progress-last-task-index* object) ;; unknown type (define-extern *progress-last-task-index* int)
;; ---------------------- ;; ----------------------
@ -14291,7 +14322,6 @@
;; - Functions ;; - Functions
(define-extern link-begin (function pointer (pointer uint8) int kheap link-flag int)) (define-extern link-begin (function pointer (pointer uint8) int kheap link-flag int))
(define-extern string->sound-name (function string sound-name))
(define-extern str-load (function string int pointer int symbol)) (define-extern str-load (function string int pointer int symbol))
(define-extern str-load-status (function (pointer int32) symbol)) (define-extern str-load-status (function (pointer int32) symbol))
(define-extern str-load-cancel (function none)) (define-extern str-load-cancel (function none))
@ -14381,94 +14411,96 @@
;; - Types ;; - Types
; (deftype sound-iop-info (basic) (deftype sound-iop-info (basic)
; ((frame uint32 :offset-assert 16) ((frame uint32 :offset 16)
; (strpos int32 :offset-assert 20) (strpos int32 :offset-assert 20)
; (str-id uint32 :offset-assert 24) (str-id uint32 :offset-assert 24)
; (str-id-sign int32 :offset-assert 24) (str-id-sign int32 :offset 24)
; (freemem uint32 :offset-assert 28) (freemem uint32 :offset-assert 28)
; (chinfo UNKNOWN 48 :offset-assert 32) (chinfo uint8 48 :offset-assert 32)
; (freemem2 uint32 :offset-assert 80) (freemem2 uint32 :offset-assert 80)
; (nocd uint32 :offset-assert 84) (nocd uint32 :offset-assert 84)
; (dirtycd uint32 :offset-assert 88) (dirtycd uint32 :offset-assert 88)
; (diskspeed UNKNOWN 2 :offset-assert 92) (diskspeed uint32 2 :offset-assert 92)
; (lastspeed uint32 :offset-assert 100) (lastspeed uint32 :offset-assert 100)
; (dupseg int32 :offset-assert 104) (dupseg int32 :offset-assert 104)
; (times UNKNOWN 41 :offset-assert 108) (times uint32 41 :offset-assert 108)
; (times-seq uint32 :offset-assert 272) (times-seq uint32 :offset-assert 272)
; ) )
; :method-count-assert 9 :method-count-assert 9
; :size-assert #x114 :size-assert #x114
; :flag-assert #x900000114 :flag-assert #x900000114
; ) )
; (deftype flava-table-row (structure) (deftype flava-table-row (structure)
; ((music basic :offset-assert 0) ((music symbol :offset-assert 0)
; (flava UNKNOWN 50 :offset-assert 4) (flava uint8 50 :offset-assert 4)
; ) )
; :method-count-assert 9 :allow-misaligned
; :size-assert #x36 :method-count-assert 9
; :flag-assert #x900000036 :size-assert #x36
; ) :flag-assert #x900000036
)
; (deftype flava-table (basic) (deftype flava-table (basic)
; ((row UNKNOWN 20 :offset-assert 4) ((row flava-table-row 20 :inline :offset-assert 4)
; (count int32 :offset-assert 1284) (count int32 :offset-assert 1284)
; ) )
; :method-count-assert 9 :method-count-assert 9
; :size-assert #x508 :size-assert #x508
; :flag-assert #x900000508 :flag-assert #x900000508
; ) )
;; - Symbols ;; - Symbols
(define-extern target-pos function) (define-extern target-pos (function int vector))
(define-extern new-sound-id function) (define-extern new-sound-id (function sound-id))
(define-extern get-sound-buffer-entry function) (define-extern get-sound-buffer-entry (function pointer))
(define-extern sound-trans-convert function) (define-extern sound-trans-convert (function vector3w vector int))
(define-extern sound-stop function) (define-extern sound-stop (function sound-id int))
(define-extern effect-param->sound-spec function) (define-extern effect-param->sound-spec (function sound-spec sound-play-parms int sound-spec))
(define-extern ear-trans function) (define-extern ear-trans (function vector))
(define-extern sound-play-by-spec function) (define-extern sound-play-by-spec (function sound-spec sound-id vector sound-id))
(define-extern sound-play-by-name function) (define-extern sound-play-by-name (function sound-name sound-id int int int uint vector sound-id))
(define-extern *setting-control* setting-control) (define-extern *setting-control* setting-control)
(define-extern sound-angle-convert function) (define-extern sound-angle-convert (function float int))
(define-extern sound-set-ear-trans function) (define-extern sound-set-ear-trans (function vector vector float int))
(define-extern activate-progress function) (define-extern activate-progress (function process int int))
(define-extern sound-command->string function) (define-extern sound-command->string (function sound-command string))
(define-extern sound-name= function) (define-extern sound-name= (function sound-name sound-name symbol))
(define-extern str-is-playing? function) (define-extern str-is-playing? (function symbol))
(define-extern current-str-id function) (define-extern current-str-id (function int))
(define-extern current-str-pos function) (define-extern current-str-pos (function int int))
(define-extern is-cd-in? function) (define-extern is-cd-in? (function symbol))
(define-extern check-irx-version function) (define-extern check-irx-version (function int))
(define-extern sound-bank-load function) (define-extern sound-bank-load (function sound-name sound-id))
(define-extern sound-bank-unload function) (define-extern sound-bank-unload (function sound-name int))
(define-extern sound-music-load function) (define-extern sound-music-load (function sound-name int))
(define-extern sound-music-unload function) (define-extern sound-music-unload (function int))
(define-extern sound-reload-info function) (define-extern sound-reload-info (function int))
(define-extern set-language function) (define-extern set-language (function int int))
(define-extern list-sounds function) (define-extern list-sounds (function int))
(define-extern sound-buffer-dump function) (define-extern sound-buffer-dump (function int))
(define-extern swap-sound-buffers function) (define-extern swap-sound-buffers (function vector vector float int))
(define-extern free-last-sound-buffer-entry function) (define-extern free-last-sound-buffer-entry (function int))
(define-extern sound-basic-cb function) (define-extern sound-basic-cb function)
(define-extern sound-set-volume function) (define-extern string->sound-name (function string sound-name))
(define-extern sound-set-reverb function) (define-extern sound-set-volume (function uint float int))
(define-extern sound-pause function) (define-extern sound-set-reverb (function int float float uint int))
(define-extern sound-continue function) (define-extern sound-pause (function sound-id int))
(define-extern sound-group-pause function) (define-extern sound-continue (function sound-id int))
(define-extern sound-group-stop function) (define-extern sound-group-pause (function uint int))
(define-extern sound-group-continue function) (define-extern sound-group-stop (function uint int))
(define-extern sound-set-falloff-curve function) (define-extern sound-group-continue (function uint int))
(define-extern sound-set-sound-falloff function) (define-extern sound-set-falloff-curve (function int float float int))
(define-extern sound-set-flava function) (define-extern sound-set-sound-falloff (function sound-name int int int int))
(define-extern sound-volume-off function) (define-extern sound-set-flava (function uint int))
(define-extern show-iop-info function) (define-extern sound-volume-off (function int))
(define-extern show-iop-memory function) (define-extern show-iop-info (function dma-buffer int))
(define-extern make-sqrt-table function) (define-extern show-iop-memory (function dma-buffer int))
(define-extern flava-lookup function) (define-extern make-sqrt-table (function int))
(define-extern flava-lookup (function symbol int integer))
;; - Functions ;; - Functions
@ -14477,14 +14509,14 @@
;; - Unknowns ;; - Unknowns
;;(define-extern *flava-table* object) ;; unknown type (define-extern *flava-table* flava-table) ;; unknown type
;;(define-extern *sound-iop-info* object) ;; unknown type (define-extern *sound-iop-info* sound-iop-info) ;; unknown type
;;(define-extern *ambient-spec* object) ;; unknown type (define-extern *ambient-spec* sound-spec) ;; unknown type
;;(define-extern *debug-effect-control* object) ;; unknown type (define-extern *debug-effect-control* symbol) ;; unknown type
;;(define-extern *sound-player-enable* object) ;; unknown type (define-extern *sound-player-enable* symbol) ;; unknown type
;;(define-extern *sound-player-rpc* object) ;; unknown type (define-extern *sound-player-rpc* rpc-buffer-pair) ;; unknown type
;;(define-extern *sound-loader-rpc* object) ;; unknown type (define-extern *sound-loader-rpc* rpc-buffer-pair) ;; unknown type
;;(define-extern kset-language object) ;; unknown type (define-extern kset-language (function int int)) ;; unknown type
;; ---------------------- ;; ----------------------
@ -18438,7 +18470,7 @@
; (active-distance float :offset-assert 184) ; (active-distance float :offset-assert 184)
; (seek-time uint64 :offset-assert 192) ; (seek-time uint64 :offset-assert 192)
; (dest vector :inline :offset-assert 208) ; (dest vector :inline :offset-assert 208)
; (sound-id uint32 :offset-assert 224) ; (sound-id sound-id :offset-assert 224)
; ) ; )
; :method-count-assert 20 ; :method-count-assert 20
; :size-assert #xe4 ; :size-assert #xe4
@ -22386,7 +22418,7 @@
; (spawn-distance meters :offset-assert 472) ; (spawn-distance meters :offset-assert 472)
; (chase-speed meters :offset-assert 476) ; (chase-speed meters :offset-assert 476)
; (y-speed meters :offset-assert 480) ; (y-speed meters :offset-assert 480)
; (sound-id uint32 :offset-assert 484) ; (sound-id sound-id :offset-assert 484)
; (enable-patrol basic :offset-assert 488) ; (enable-patrol basic :offset-assert 488)
; ) ; )
; :method-count-assert 76 ; :method-count-assert 76
@ -22546,7 +22578,7 @@
; (deftype plat (baseplat) ; (deftype plat (baseplat)
; ((path-pos float :offset-assert 228) ; ((path-pos float :offset-assert 228)
; (sync sync-info-eased :inline :offset-assert 232) ; (sync sync-info-eased :inline :offset-assert 232)
; (sound-id uint32 :offset-assert 260) ; (sound-id sound-id :offset-assert 260)
; ) ; )
; :method-count-assert 33 ; :method-count-assert 33
; :size-assert #x108 ; :size-assert #x108
@ -22603,7 +22635,7 @@
; (path-pos float :offset-assert 188) ; (path-pos float :offset-assert 188)
; (bidirectional? basic :offset-assert 192) ; (bidirectional? basic :offset-assert 192)
; (allow-auto-kill basic :offset-assert 196) ; (allow-auto-kill basic :offset-assert 196)
; (sound-id uint32 :offset-assert 200) ; (sound-id sound-id :offset-assert 200)
; (trans-off vector :inline :offset-assert 208) ; (trans-off vector :inline :offset-assert 208)
; (spawn-pos vector :inline :offset-assert 224) ; (spawn-pos vector :inline :offset-assert 224)
; ) ; )
@ -22918,8 +22950,8 @@
; (at-point vector :inline :offset-assert 336) ; (at-point vector :inline :offset-assert 336)
; (accuracy-range float :offset-assert 352) ; (accuracy-range float :offset-assert 352)
; (target-theta float :offset-assert 356) ; (target-theta float :offset-assert 356)
; (sound-id uint32 :offset-assert 360) ; (sound-id sound-id :offset-assert 360)
; (aim-sound-id uint32 :offset-assert 364) ; (aim-sound-id sound-id :offset-assert 364)
; (player-touching-grips? basic :offset-assert 368) ; (player-touching-grips? basic :offset-assert 368)
; ) ; )
; :method-count-assert 24 ; :method-count-assert 24
@ -23231,7 +23263,7 @@
;; - Types ;; - Types
; (deftype windmill-one (process-drawable) ; (deftype windmill-one (process-drawable)
; ((sound-id uint32 :offset-assert 176) ; ((sound-id sound-id :offset-assert 176)
; ) ; )
; :method-count-assert 20 ; :method-count-assert 20
; :size-assert #xb4 ; :size-assert #xb4
@ -26101,7 +26133,7 @@
; (beam-on basic :offset-assert 468) ; (beam-on basic :offset-assert 468)
; (resolution-anim basic :offset-assert 472) ; (resolution-anim basic :offset-assert 472)
; (sound-name basic :offset-assert 476) ; (sound-name basic :offset-assert 476)
; (sound-id uint32 :offset-assert 480) ; (sound-id sound-id :offset-assert 480)
; (alt-actor basic :offset-assert 484) ; (alt-actor basic :offset-assert 484)
; ) ; )
; :method-count-assert 53 ; :method-count-assert 53
@ -28985,8 +29017,8 @@
;; - Types ;; - Types
; (deftype eggtop (process-drawable) ; (deftype eggtop (process-drawable)
; ((cam-tracker uint64 :offset-assert 176) ; ((cam-tracker uint64 :offset-assert 176)
; (sound-id uint32 :offset-assert 184) ; (sound-id sound-id :offset-assert 184)
; ) ; )
; :method-count-assert 20 ; :method-count-assert 20
; :size-assert #xbc ; :size-assert #xbc
@ -30165,9 +30197,9 @@
; (raised? basic :offset-assert 356) ; (raised? basic :offset-assert 356)
; (player-touching-grips? basic :offset-assert 360) ; (player-touching-grips? basic :offset-assert 360)
; (grips-moving? basic :offset-assert 364) ; (grips-moving? basic :offset-assert 364)
; (sound-id uint32 :offset-assert 368) ; (sound-id sound-id :offset-assert 368)
; (rise-sound-id uint32 :offset-assert 372) ; (rise-sound-id sound-id :offset-assert 372)
; (grips-sound-id uint32 :offset-assert 376) ; (grips-sound-id sound-id :offset-assert 376)
; (grips basic :offset-assert 380) ; (grips basic :offset-assert 380)
; (part-aligned basic :offset-assert 384) ; (part-aligned basic :offset-assert 384)
; ) ; )
@ -31051,8 +31083,8 @@
; (hop-start-y float :offset-assert 468) ; (hop-start-y float :offset-assert 468)
; (bounce int32 :offset-assert 472) ; (bounce int32 :offset-assert 472)
; (bounce-hit float :offset-assert 476) ; (bounce-hit float :offset-assert 476)
; (engine-sound-id uint32 :offset-assert 480) ; (engine-sound-id sound-id :offset-assert 480)
; (boost-sound-id uint32 :offset-assert 484) ; (boost-sound-id sound-id :offset-assert 484)
; (engine-sound-pitch float :offset-assert 488) ; (engine-sound-pitch float :offset-assert 488)
; (turn-anim-targ float :offset-assert 492) ; (turn-anim-targ float :offset-assert 492)
; (turn-anim-frame float :offset-assert 496) ; (turn-anim-frame float :offset-assert 496)
@ -31067,7 +31099,7 @@
; (heavy basic :offset-assert 536) ; (heavy basic :offset-assert 536)
; (unstuck-time uint64 :offset-assert 544) ; (unstuck-time uint64 :offset-assert 544)
; (stuck-count int32 :offset-assert 552) ; (stuck-count int32 :offset-assert 552)
; (scrape-sound-id uint32 :offset-assert 556) ; (scrape-sound-id sound-id :offset-assert 556)
; (heat-sound-time uint64 :offset-assert 560) ; (heat-sound-time uint64 :offset-assert 560)
; ) ; )
; :method-count-assert 9 ; :method-count-assert 9
@ -31668,7 +31700,7 @@
;; - Types ;; - Types
; (deftype assistant (process-taskable) ; (deftype assistant (process-taskable)
; ((sound-id uint32 :offset-assert 380) ; ((sound-id sound-id :offset-assert 380)
; ) ; )
; :method-count-assert 53 ; :method-count-assert 53
; :size-assert #x180 ; :size-assert #x180
@ -32470,7 +32502,7 @@
; (cam-tracker uint64 :offset-assert 1064) ; (cam-tracker uint64 :offset-assert 1064)
; (player-attack-id int32 :offset-assert 696) ; (player-attack-id int32 :offset-assert 696)
; (kill-player basic :offset-assert 1076) ; (kill-player basic :offset-assert 1076)
; (engine-sound-id uint32 :offset-assert 1080) ; (engine-sound-id sound-id :offset-assert 1080)
; (engine-sound-envelope float :offset-assert 1084) ; (engine-sound-envelope float :offset-assert 1084)
; (debug-draw basic :offset-assert 1088) ; (debug-draw basic :offset-assert 1088)
; (debug-path-record basic :offset-assert 1092) ; (debug-path-record basic :offset-assert 1092)
@ -33353,7 +33385,7 @@
; (path-position vector :inline :offset-assert 192) ; (path-position vector :inline :offset-assert 192)
; (shadow-enable-plane vector :inline :offset-assert 208) ; (shadow-enable-plane vector :inline :offset-assert 208)
; (smush smush-control :inline :offset-assert 224) ; (smush smush-control :inline :offset-assert 224)
; (sound-id uint32 :offset-assert 256) ; (sound-id sound-id :offset-assert 256)
; ) ; )
; :method-count-assert 20 ; :method-count-assert 20
; :size-assert #x104 ; :size-assert #x104
@ -33857,8 +33889,8 @@
; (auto-pilot basic :offset-assert 852) ; (auto-pilot basic :offset-assert 852)
; (dead basic :offset-assert 856) ; (dead basic :offset-assert 856)
; (anim-frame float :offset-assert 860) ; (anim-frame float :offset-assert 860)
; (engine-sound-id uint32 :offset-assert 864) ; (engine-sound-id sound-id :offset-assert 864)
; (pedal-sound-id uint32 :offset-assert 868) ; (pedal-sound-id sound-id :offset-assert 868)
; (frame-count int8 :offset-assert 872) ; (frame-count int8 :offset-assert 872)
; ) ; )
; :method-count-assert 35 ; :method-count-assert 35
@ -35000,7 +35032,7 @@
;; - Types ;; - Types
; (deftype assistant-bluehut (process-taskable) ; (deftype assistant-bluehut (process-taskable)
; ((sound-id uint32 :offset-assert 380) ; ((sound-id sound-id :offset-assert 380)
; (jaws uint64 :offset-assert 384) ; (jaws uint64 :offset-assert 384)
; (sage basic :offset-assert 392) ; (sage basic :offset-assert 392)
; (im-talking basic :offset-assert 396) ; (im-talking basic :offset-assert 396)
@ -35993,7 +36025,7 @@
; ) ; )
; (deftype kermit-pulse (process-drawable) ; (deftype kermit-pulse (process-drawable)
; ((sound-id uint32 :offset-assert 176) ; ((sound-id sound-id :offset-assert 176)
; ) ; )
; :method-count-assert 20 ; :method-count-assert 20
; :size-assert #xb4 ; :size-assert #xb4
@ -36022,7 +36054,7 @@
; (tongue-pulse-pos float :offset-assert 428) ; (tongue-pulse-pos float :offset-assert 428)
; (miss-count int8 :offset-assert 432) ; (miss-count int8 :offset-assert 432)
; (charged-up basic :offset-assert 436) ; (charged-up basic :offset-assert 436)
; (sound-id uint32 :offset-assert 440) ; (sound-id sound-id :offset-assert 440)
; ) ; )
; :method-count-assert 76 ; :method-count-assert 76
; :size-assert #x1bc ; :size-assert #x1bc
@ -37543,7 +37575,7 @@
; (turn-anim-targ float :offset-assert 128) ; (turn-anim-targ float :offset-assert 128)
; (turn-anim-frame float :offset-assert 132) ; (turn-anim-frame float :offset-assert 132)
; (turn-anim-vel float :offset-assert 136) ; (turn-anim-vel float :offset-assert 136)
; (tube-sound-id uint32 :offset-assert 140) ; (tube-sound-id sound-id :offset-assert 140)
; (tube-sound-vol float :offset-assert 144) ; (tube-sound-vol float :offset-assert 144)
; ) ; )
; :method-count-assert 9 ; :method-count-assert 9
@ -41874,7 +41906,7 @@
; (path-coming-out-u float :offset-assert 196) ; (path-coming-out-u float :offset-assert 196)
; (path-faded-up-u float :offset-assert 200) ; (path-faded-up-u float :offset-assert 200)
; (delay-til-bounce int32 :offset-assert 204) ; (delay-til-bounce int32 :offset-assert 204)
; (rolling-sound-id uint32 :offset-assert 208) ; (rolling-sound-id sound-id :offset-assert 208)
; (rolling-sound-enabled? basic :offset-assert 212) ; (rolling-sound-enabled? basic :offset-assert 212)
; (last-bounce-time uint64 :offset-assert 216) ; (last-bounce-time uint64 :offset-assert 216)
; (hit-player-time uint64 :offset-assert 224) ; (hit-player-time uint64 :offset-assert 224)
@ -42517,7 +42549,7 @@
; ((part2 basic :offset-assert 412) ; ((part2 basic :offset-assert 412)
; (launched? basic :offset-assert 416) ; (launched? basic :offset-assert 416)
; (growth float :offset-assert 420) ; (growth float :offset-assert 420)
; (charge-sound-id uint32 :offset-assert 424) ; (charge-sound-id sound-id :offset-assert 424)
; (launch-time uint64 :offset-assert 432) ; (launch-time uint64 :offset-assert 432)
; (facing-dir vector :inline :offset-assert 448) ; (facing-dir vector :inline :offset-assert 448)
; ) ; )

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

@ -526,5 +526,22 @@
], ],
"entity": [ "entity": [
["L324", "float", true] ["L324", "float", true]
],
"gsound": [
["L137", "float", true],
["L138", "float", true],
["L139", "float", true],
["L140", "float", true],
["L141", "float", true],
["L142", "float", true],
["L143", "float", true],
["L144", "float", true],
["L145", "float", true],
["L146", "float", true],
["L271", "uint64", true],
["L276", "uint64", true],
["L275", "uint64", true],
["L133", "_auto_", true]
] ]
} }

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

@ -542,5 +542,51 @@
"(method 9 actor-link-info)": [[[0, 36], "s3", "entity-actor"]], "(method 9 actor-link-info)": [[[0, 36], "s3", "entity-actor"]],
"alt-actor-list-subtask-incomplete-count": [[19, "a0", "entity-links"]], "alt-actor-list-subtask-incomplete-count": [[19, "a0", "entity-links"]],
"actor-link-dead-hook": [[1, "v1", "entity-links"]], "actor-link-dead-hook": [[1, "v1", "entity-links"]],
"actor-link-subtask-complete-hook": [[1, "v1", "entity-links"]] "actor-link-subtask-complete-hook": [[1, "v1", "entity-links"]],
"check-irx-version": [[[6, 37], "gp", "sound-rpc-get-irx-version"]],
"sound-bank-load": [[[9, 11], "v1", "sound-rpc-load-bank"]],
"sound-bank-unload": [[[7, 9], "v1", "sound-rpc-unload-bank"]],
"sound-music-load": [[[7, 9], "v1", "sound-rpc-load-music"]],
"sound-music-unload": [[6, "v1", "sound-rpc-unload-music"]],
"sound-reload-info": [[6, "v1", "sound-rpc-reload-info"]],
"set-language": [[[10, 12], "v1", "sound-rpc-set-language"]],
"list-sounds": [[6, "v1", "sound-rpc-list-sounds"]],
"sound-set-volume": [[[6, 13], "v1", "sound-rpc-set-master-volume"]],
"sound-set-reverb": [[[8, 21], "v1", "sound-rpc-set-reverb"]],
"sound-set-ear-trans": [[[7, 20], "gp", "sound-rpc-set-ear-trans"]],
"sound-play-by-name": [
[[13, 45], "s5", "sound-rpc-play"],
[[22, 39], "s3", "process-drawable"]
],
"sound-play-by-spec": [
[[9, 54], "s5", "sound-rpc-play"],
[[31, 47], "s3", "process-drawable"]
],
"sound-pause": [[[5, 7], "v1", "sound-rpc-pause-sound"]],
"sound-stop": [[[5, 7], "v1", "sound-rpc-stop-sound"]],
"sound-continue": [[[5, 7], "v1", "sound-rpc-continue-sound"]],
"sound-group-pause": [[[5, 7], "v1", "sound-rpc-pause-group"]],
"sound-group-stop": [[[5, 7], "v1", "sound-rpc-stop-group"]],
"sound-group-continue": [[[5, 7], "v1", "sound-rpc-continue-group"]],
"sound-set-falloff-curve": [[[7, 19], "v1", "sound-rpc-set-falloff-curve"]],
"sound-set-sound-falloff": [[[8, 13], "v1", "sound-rpc-set-sound-falloff"]],
"sound-set-flava": [[[5, 7], "v1", "sound-rpc-set-flava"]],
"(method 0 ambient-sound)": [
[136, "v1", "sound-spec"],
[143, "v1", "sound-spec"],
[140, "v1", "sound-spec"],
[147, "v1", "sound-spec"],
["_stack_", 16, "sound-spec"],
["_stack_", 32, "sound-name"],
["_stack_", 48, "(pointer float)"],
["_stack_", 52, "sound-play-parms"],
["_stack_", 64, "res-tag"]
],
"(method 11 ambient-sound)": [
[[18, 31], "s4", "process-drawable"],
[[12, 44], "gp", "sound-rpc-set-param"]
],
"(method 12 ambient-sound)": [[[8, 20], "v1", "sound-rpc-set-param"]],
"sound-buffer-dump": [[[14, 25], "s3", "sound-rpc-play"]]
} }

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

@ -1870,6 +1870,90 @@
"alt-actor-list-subtask-incomplete-count": { "alt-actor-list-subtask-incomplete-count": {
"vars":{"s4-0":"alt-actor-count", "gp-0":"incomplete-count", "s3-0":"alt-actor-idx"} "vars":{"s4-0":"alt-actor-count", "gp-0":"incomplete-count", "s3-0":"alt-actor-idx"}
},
"check-irx-version": {
"vars": { "gp-0": ["cmd", "sound-rpc-get-irx-version"] }
},
"sound-bank-load": {
"vars": { "v1-1": ["cmd", "sound-rpc-load-bank"] }
},
"sound-bank-unload": {
"vars": { "v1-1": ["cmd", "sound-rpc-unload-bank"] }
},
"sound-music-load": {
"vars": { "v1-1": ["cmd", "sound-rpc-load-music"] }
},
"sound-music-unload": {
"vars": { "v1-1": ["cmd", "sound-rpc-unload-music"] }
},
"sound-reload-info": {
"vars": { "v1-1": ["cmd", "sound-rpc-reload-info"] }
},
"set-language": {
"vars": { "v1-1": ["cmd", "sound-rpc-set-language"] }
},
"list-sounds": {
"vars": { "v1-1": ["cmd", "sound-rpc-list-sounds"] }
},
"sound-set-volume": {
"vars": { "v1-0": ["cmd", "sound-rpc-set-master-volume"] }
},
"sound-set-reverb": {
"vars": { "v1-0": ["cmd", "sound-rpc-set-reverb"] }
},
"sound-set-ear-trans": {
"vars": { "gp-0": ["cmd", "sound-rpc-set-ear-trans"] }
},
"sound-play-by-name": {
"args": [ "name", "id", "vol", "pitch", "bend", "group", "trans" ],
"vars": { "s5-0": ["cmd", "sound-rpc-play"], "s3-1": ["proc", "process-drawable"], "s4-0": "sound-trans" }
},
"sound-play-by-spec": {
"args": [ "spec", "id", "trans" ],
"vars": { "s5-0": ["cmd", "sound-rpc-play"], "s3-1": ["proc", "process-drawable"] }
},
"sound-pause": {
"vars": { "v1-0": ["cmd", "sound-rpc-pause-sound"] }
},
"sound-stop": {
"vars": { "v1-0": ["cmd", "sound-rpc-stop-sound"] }
},
"sound-continue": {
"vars": { "v1-0": ["cmd", "sound-rpc-continue-sound"] }
},
"sound-group-pause": {
"vars": { "v1-0": ["cmd", "sound-rpc-pause-group"] }
},
"sound-group-stop": {
"vars": { "v1-0": ["cmd", "sound-rpc-stop-group"] }
},
"sound-group-continue": {
"vars": { "v1-0": ["cmd", "sound-rpc-continue-group"] }
},
"sound-set-falloff-curve": {
"vars": { "v1-0": ["cmd", "sound-rpc-set-falloff-curve"] }
},
"sound-set-sound-falloff": {
"vars": { "v1-0": ["cmd", "sound-rpc-set-sound-falloff"] }
},
"sound-set-flava": {
"vars": { "v1-0": ["cmd", "sound-rpc-set-flava"] }
},
"(method 0 ambient-sound)": {
"vars": { "s5-1": ["obj", "ambient-sound"], "v1-2": "bc" }
},
"(method 9 ambient-sound)": {
"vars": { "s5-1": "spec", "s4-2": "spec-volume" }
},
"(method 11 ambient-sound)": {
"vars": { "gp-0": ["cmd", "sound-rpc-set-param"] }
},
"(method 12 ambient-sound)": {
"vars": { "v1-2": ["cmd", "sound-rpc-set-param"] }
},
"sound-buffer-dump": {
"vars": { "s3-0": ["cmd", "sound-rpc-play"] }
} }

29
goal_src/engine/data/res.gc
View file

@ -444,12 +444,26 @@ This is updated from the entity system used in Crash 2, which had most of these
default default
) )
(defmacro res-lump-data (lump name type &key (tag-ptr (the-as (pointer res-tag) #f))) (defmacro res-lump-data (lump name type &key (tag-ptr (the-as (pointer res-tag) #f)) &key (time -1000000000.0))
"Helper macro to get data from a res-lump without interpolation." "Helper macro to get data from a res-lump without interpolation."
`(the-as ,type ((method-of-type res-lump get-property-data) `(the-as ,type ((method-of-type res-lump get-property-data)
,lump ,lump
,name ,name
'interp 'interp
,time
(the-as pointer #f)
,tag-ptr
*res-static-buf*
)
)
)
(defmacro res-lump-data-exact (lump name type &key (tag-ptr (the-as (pointer res-tag) #f)))
"Helper macro to get start of data from a res-lump."
`(the-as ,type ((method-of-type res-lump get-property-data)
,lump
,name
'exact
0.0 0.0
(the-as pointer #f) (the-as pointer #f)
,tag-ptr ,tag-ptr
@ -500,6 +514,19 @@ This is updated from the entity system used in Crash 2, which had most of these
) )
) )
(defmacro res-lump-struct-exact (lump name type &key (tag-ptr (the-as (pointer res-tag) #f)))
`(the-as ,type ((method-of-type res-lump get-property-struct)
,lump
,name
'exact
0.0
(the-as structure #f)
,tag-ptr
*res-static-buf*
)
)
)
(defmethod get-property-value res-lump ((obj res-lump) (name symbol) (mode symbol) (time float) (default uint128) (tag-addr (pointer res-tag)) (buf-addr pointer)) (defmethod get-property-value res-lump ((obj res-lump) (name symbol) (mode symbol) (time float) (default uint128) (tag-addr (pointer res-tag)) (buf-addr pointer))
"Returns a given value property's value at a specific time stamp, or default on error. "Returns a given value property's value at a specific time stamp, or default on error.
name is the name of the property you want, mode is its lookup mode ('interp 'base 'exact), time is the timestamp. name is the name of the property you want, mode is its lookup mode ('interp 'base 'exact), time is the timestamp.

2
goal_src/engine/draw/drawable-ambient-h.gc
View file

@ -59,7 +59,7 @@
((text-id-to-display uint32 :offset-assert 112) ((text-id-to-display uint32 :offset-assert 112)
(sound-to-play basic :offset-assert 116) (sound-to-play basic :offset-assert 116)
(trans vector :offset-assert 120) (trans vector :offset-assert 120)
(sound-id uint32 :offset-assert 124) (sound-id sound-id :offset-assert 124)
(mode basic :offset-assert 128) (mode basic :offset-assert 128)
(total-time uint64 :offset-assert 136) (total-time uint64 :offset-assert 136)
(total-off-time uint64 :offset-assert 144) (total-off-time uint64 :offset-assert 144)

2
goal_src/engine/game/fact-h.gc
View file

@ -165,7 +165,7 @@
(set! (-> obj process) proc) (set! (-> obj process) proc)
;; eco may override the pickup type and amount, so try to get this. ;; eco may override the pickup type and amount, so try to get this.
(let ((v1-6 (res-lump-data ent 'eco-info (pointer int32) :tag-ptr (& tag)))) (let ((v1-6 (res-lump-data ent 'eco-info (pointer int32) :tag-ptr (& tag) :time 0.0)))
(cond (cond
(v1-6 (v1-6
;; eco-info lookup succeeded, ;; eco-info lookup succeeded,

2
goal_src/engine/game/projectiles-h.gc
View file

@ -28,7 +28,7 @@
(update-velocity basic :offset-assert 396) (update-velocity basic :offset-assert 396)
(counter int32 :offset-assert 400) (counter int32 :offset-assert 400)
(target-count int32 :offset-assert 404) (target-count int32 :offset-assert 404)
(sound-id uint32 :offset-assert 408) (sound-id sound-id :offset-assert 408)
) )
:heap-base #x130 :heap-base #x130
:method-count-assert 29 :method-count-assert 29

3
goal_src/engine/game/settings-h.gc
View file

@ -5,6 +5,7 @@
;; name in dgo: settings-h ;; name in dgo: settings-h
;; dgos: GAME, ENGINE ;; dgos: GAME, ENGINE
;; was manually done
(deftype setting-data (structure) (deftype setting-data (structure)
((border-mode basic :offset-assert 0) ((border-mode basic :offset-assert 0)
(sfx-volume float :offset-assert 4) (sfx-volume float :offset-assert 4)
@ -108,7 +109,7 @@
(:methods (:methods
(new (symbol type int) _type_ 0) (new (symbol type int) _type_ 0)
(dummy-9 () none 9) (dummy-9 () none 9)
(dummy-10 () none 10) (dummy-10 (_type_ process symbol symbol float int) none 10)
(dummy-11 () none 11) (dummy-11 () none 11)
(dummy-12 () none 12) (dummy-12 () none 12)
(dummy-13 () none 13) (dummy-13 () none 13)

3
goal_src/engine/math/vector-h.gc
View file

@ -186,11 +186,12 @@
;; Vector of 3 signed words ;; Vector of 3 signed words
(deftype vector3w (structure) (deftype vector3w (structure)
((data int32 3 :offset-assert 0) ((data int32 3 :do-not-decompile :offset-assert 0)
(x int32 :offset 0) (x int32 :offset 0)
(y int32 :offset 4) (y int32 :offset 4)
(z int32 :offset 8) (z int32 :offset 8)
) )
:allow-misaligned
:method-count-assert 9 :method-count-assert 9
:size-assert #xc :size-assert #xc
:flag-assert #x90000000c :flag-assert #x90000000c

97
goal_src/engine/sound/gsound-h.gc
View file

@ -23,16 +23,45 @@
) )
;; Sound names were sometimes packed into a uint128 ;; Sound names were sometimes packed into a uint128
;; fields added by us
(deftype sound-name (uint128) (deftype sound-name (uint128)
() ((lo uint64 :offset 0)
(hi uint64 :offset 64)
)
:flag-assert #x900000010 :flag-assert #x900000010
) )
(defenum sound-command
:type uint16
(load-bank)
(load-music)
(unload-bank)
(play)
(pause-sound)
(stop-sound)
(continue-sound)
(set-param)
(set-master-volume)
(pause-group)
(stop-group)
(continue-group)
(get-irx-version)
(set-falloff-curve)
(set-sound-falloff)
(reload-info)
(set-language)
(set-flava)
(set-reverb)
(set-ear-trans)
(shutdown)
(list-sounds)
(unload-music)
)
;; like should match the sound type in OVERLORD ;; like should match the sound type in OVERLORD
;; This is shared between all sound RPCs. ;; This is shared between all sound RPCs.
(deftype sound-rpc-cmd (structure) (deftype sound-rpc-cmd (structure)
((rsvd1 uint16 :offset-assert 0) ((rsvd1 uint16 :offset-assert 0)
(command uint16 :offset-assert 2) (command sound-command :offset-assert 2)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x4 :size-assert #x4
@ -48,7 +77,7 @@
(fo-curve int8 :offset-assert 10) (fo-curve int8 :offset-assert 10)
(priority int8 :offset-assert 11) (priority int8 :offset-assert 11)
(volume int32 :offset-assert 12) (volume int32 :offset-assert 12)
(trans float 3 :offset-assert 16) ;; guess on type here (trans vector3w :inline :offset-assert 16)
(group uint8 :offset-assert 28) (group uint8 :offset-assert 28)
) )
:pack-me :pack-me
@ -58,7 +87,7 @@
) )
(deftype sound-rpc-bank-cmd (sound-rpc-cmd) (deftype sound-rpc-bank-cmd (sound-rpc-cmd)
((bank-name uint128 :offset-assert 16) ((bank-name sound-name :offset-assert 16)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x20 :size-assert #x20
@ -66,7 +95,7 @@
) )
(deftype sound-rpc-sound-cmd (sound-rpc-cmd) (deftype sound-rpc-sound-cmd (sound-rpc-cmd)
((id uint32 :offset-assert 4) ((id sound-id :offset-assert 4)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x8 :size-assert #x8
@ -103,7 +132,7 @@
) )
(deftype sound-rpc-play (sound-rpc-sound-cmd) (deftype sound-rpc-play (sound-rpc-sound-cmd)
((name uint128 :offset-assert 16) ((name sound-name :offset-assert 16)
(parms sound-play-parms :inline :offset-assert 32) (parms sound-play-parms :inline :offset-assert 32)
) )
:method-count-assert 9 :method-count-assert 9
@ -174,7 +203,7 @@
(deftype sound-rpc-get-irx-version (sound-rpc-cmd) (deftype sound-rpc-get-irx-version (sound-rpc-cmd)
((major uint32 :offset-assert 4) ((major uint32 :offset-assert 4)
(minor uint32 :offset-assert 8) (minor uint32 :offset-assert 8)
(ee-addr uint32 :offset-assert 12) (ee-addr pointer :offset-assert 12)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x10 :size-assert #x10
@ -200,7 +229,7 @@
) )
(deftype sound-rpc-set-sound-falloff (sound-rpc-cmd) (deftype sound-rpc-set-sound-falloff (sound-rpc-cmd)
((name uint128 :offset-assert 16) ((name sound-name :offset-assert 16)
(curve int32 :offset-assert 32) (curve int32 :offset-assert 32)
(min int32 :offset-assert 36) (min int32 :offset-assert 36)
(max int32 :offset-assert 40) (max int32 :offset-assert 40)
@ -229,8 +258,8 @@
) )
(deftype sound-rpc-set-ear-trans (sound-rpc-cmd) (deftype sound-rpc-set-ear-trans (sound-rpc-cmd)
((ear-trans float 3 :offset-assert 4) ;; guess on float, may be fixed point ((ear-trans vector3w :inline :offset-assert 4)
(cam-trans float 3 :offset-assert 16) (cam-trans vector3w :inline :offset-assert 16)
(cam-angle int32 :offset-assert 28) (cam-angle int32 :offset-assert 28)
) )
:method-count-assert 9 :method-count-assert 9
@ -303,7 +332,7 @@
(num float :offset-assert 8) (num float :offset-assert 8)
(group uint8 :offset-assert 12) (group uint8 :offset-assert 12)
(sound-name-char uint8 16 :offset 16) (sound-name-char uint8 16 :offset 16)
(sound-name uint128 :offset 16) (sound-name sound-name :offset 16)
(trans float 4 :offset-assert 32) ;; guess (trans float 4 :offset-assert 32) ;; guess
(volume int32 :offset-assert 48) (volume int32 :offset-assert 48)
(pitch-mod int32 :offset-assert 52) (pitch-mod int32 :offset-assert 52)
@ -322,33 +351,35 @@
(define *current-sound-id* (the sound-id 65536)) (define *current-sound-id* (the sound-id 65536))
(declare-type entity basic)
(deftype ambient-sound (basic) (deftype ambient-sound (basic)
((spec basic :offset-assert 4) ((spec sound-spec :offset-assert 4)
(playing-id uint32 :offset-assert 8) (playing-id sound-id :offset-assert 8)
(trans vector :inline :offset-assert 16) (trans vector :inline :offset-assert 16)
(name uint128 :offset-assert 32) (name sound-name :offset-assert 32)
(play-time uint64 :offset-assert 48) (play-time uint64 :offset-assert 48)
(time-base uint64 :offset-assert 56) (time-base uint64 :offset-assert 56)
(time-random uint64 :offset-assert 64) (time-random uint64 :offset-assert 64)
(volume int32 :offset-assert 72) (volume int32 :offset-assert 72)
(pitch int32 :offset-assert 76) (pitch int32 :offset-assert 76)
(falloff-near int32 :offset-assert 80) (falloff-near int32 :offset-assert 80)
(falloff-far int32 :offset-assert 84) (falloff-far int32 :offset-assert 84)
(falloff-mode int32 :offset-assert 88) (falloff-mode int32 :offset-assert 88)
(params uint32 :offset-assert 92) (params sound-play-parms :offset-assert 92)
(param-count int32 :offset-assert 96) (param-count int32 :offset-assert 96)
(entity basic :offset-assert 100) (entity entity :offset-assert 100)
(sound-count int32 :offset-assert 104) (sound-count int32 :offset-assert 104)
) )
:method-count-assert 14 :method-count-assert 14
:size-assert #x6c :size-assert #x6c
:flag-assert #xe0000006c :flag-assert #xe0000006c
(:methods (:methods
(dummy-9 () none 9) (new (symbol type basic vector) _type_ 0)
(dummy-10 () none 10) (dummy-9 (_type_) int 9)
(dummy-11 () none 11) (dummy-10 (_type_ sound-name) int 10)
(dummy-12 () none 12) (dummy-11 (_type_ vector) int 11)
(dummy-13 () none 13) (dummy-12 (_type_ int) int 12)
(stop! (_type_) int 13)
) )
) )
@ -356,3 +387,5 @@
(define *sound-bank-2* #f) (define *sound-bank-2* #f)
(defun-extern string->sound-name string sound-name) (defun-extern string->sound-name string sound-name)
(defun-extern sound-set-ear-trans vector vector float int)
(defun-extern ear-trans vector)

989
goal_src/engine/sound/gsound.gc
View file

@ -6,6 +6,300 @@
;; dgos: GAME, ENGINE ;; dgos: GAME, ENGINE
(define *sound-player-rpc* (new 'global 'rpc-buffer-pair (the-as uint 80) (the-as uint 128) 0))
(define *sound-loader-rpc* (new 'global 'rpc-buffer-pair (the-as uint 80) (the-as uint 1) 1))
(defun sound-name= ((arg0 sound-name) (arg1 sound-name))
"Return #t if both are the same name"
(declare (inline))
(and (= (-> arg0 lo) (-> arg1 lo))
(= (-> arg0 hi) (-> arg1 hi)))
)
(deftype sound-iop-info (basic)
((frame uint32 :offset 16)
(strpos int32 :offset-assert 20)
(str-id uint32 :offset-assert 24)
(str-id-sign int32 :offset 24)
(freemem uint32 :offset-assert 28)
(chinfo uint8 48 :offset-assert 32)
(freemem2 uint32 :offset-assert 80)
(nocd uint32 :offset-assert 84)
(dirtycd uint32 :offset-assert 88)
(diskspeed uint32 2 :offset-assert 92)
(lastspeed uint32 :offset-assert 100)
(dupseg int32 :offset-assert 104)
(times uint32 41 :offset-assert 108)
(times-seq uint32 :offset-assert 272)
)
:method-count-assert 9
:size-assert #x114
:flag-assert #x900000114
)
(define *sound-iop-info* (new 'global 'sound-iop-info))
(defun str-is-playing? ()
"Return #t if an audio stream is playing"
(!= (-> *sound-iop-info* strpos) -1)
)
(defun current-str-id ()
"Return id of the current stream"
(-> *sound-iop-info* str-id-sign)
)
(defun current-str-pos ((str int))
"Return position of the current stream. Return -1 if specified stream is not current"
(let ((ret -1))
(if (= str (-> *sound-iop-info* str-id))
(set! ret (-> *sound-iop-info* strpos))
)
ret
)
)
(defun is-cd-in? ()
(declare (inline))
(zero? (-> *sound-iop-info* nocd))
)
(defmacro is-cd-good? ()
`(zero? (-> *sound-iop-info* dirtycd))
)
(defun new-sound-id ()
(set! *current-sound-id* (the sound-id (1+ (the uint *current-sound-id*))))
(if (< (the-as int *current-sound-id*) #x10000)
(set! *current-sound-id* (the-as sound-id #x10000))
)
*current-sound-id*
)
(defun check-irx-version ()
(let ((cmd (the sound-rpc-get-irx-version (add-element *sound-loader-rpc*))))
(set! (-> cmd command) (sound-command get-irx-version))
(set! (-> cmd ee-addr) (&-> *sound-iop-info* frame))
(call *sound-loader-rpc* (the-as uint 0) (the-as pointer cmd) (the-as uint 80))
(sync *sound-loader-rpc* #f)
(format 0 "IRX version ~D.~D~%" (-> cmd major) (-> cmd minor))
(when (or (!= (-> cmd major) 2) (nonzero? (-> cmd minor)))
(format 0 "ERROR: IRX is the wrong version - need ~D.~D~%" 2 0)
(format 0 "~%~%Please do (:mch) then mkee on linux-dog~%~%~%")
(crash!)
0
)
)
0
)
;; TODO rpc 1 unimplemented
;(check-irx-version)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; sound loading
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun sound-bank-load ((name sound-name))
(let ((id (new-sound-id)))
(let ((cmd (the sound-rpc-load-bank (add-element *sound-loader-rpc*))))
(set! (-> cmd command) (sound-command load-bank))
(set! (-> cmd bank-name) name)
)
(call *sound-loader-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
id
)
)
(defun sound-bank-unload ((name sound-name))
(let ((cmd (the sound-rpc-unload-bank (add-element *sound-loader-rpc*))))
(set! (-> cmd command) (sound-command unload-bank))
(set! (-> cmd bank-name) name)
)
(call *sound-loader-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
0
)
(defun sound-music-load ((name sound-name))
(let ((cmd (the sound-rpc-load-music (add-element *sound-loader-rpc*))))
(set! (-> cmd command) (sound-command load-music))
(set! (-> cmd bank-name) name)
)
(call *sound-loader-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
0
)
(defun sound-music-unload ()
(let ((cmd (the sound-rpc-unload-music (add-element *sound-loader-rpc*))))
(set! (-> cmd command) (sound-command unload-music))
)
(call *sound-loader-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
0
)
;; TODO rpc 1 unimplemented
;(sound-bank-load (new 'static 'sound-name :lo #x6e6f6d6d6f63 :hi 0)) ;; common
;(sound-bank-load (new 'static 'sound-name :lo #x317974706d65 :hi 0)) ;; empty1
;(sound-bank-load (new 'static 'sound-name :lo #x327974706d65 :hi 0)) ;; empty2
(define *sound-bank-1* 'empty1)
(define *sound-bank-2* 'empty2)
(defun sound-reload-info ()
(let ((cmd (the sound-rpc-reload-info (add-element *sound-loader-rpc*))))
(set! (-> cmd command) (sound-command reload-info))
)
(call *sound-loader-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
0
)
(defun set-language ((lang int))
(kset-language lang)
(let ((cmd (the sound-rpc-set-language (add-element *sound-loader-rpc*))))
(set! (-> cmd command) (sound-command set-language))
(set! (-> cmd lang) (the-as uint lang))
)
(call *sound-loader-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
0
)
(defun list-sounds ()
(let ((cmd (the sound-rpc-list-sounds (add-element *sound-loader-rpc*))))
(set! (-> cmd command) (sound-command list-sounds))
)
(call *sound-loader-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
0
)
(defun-debug sound-command->string ((cmd sound-command))
(case cmd
(((sound-command unload-music)) "unload-music")
(((sound-command list-sounds)) "list-sounds")
(((sound-command shutdown)) "shutdown")
(((sound-command set-ear-trans)) "set-ear-trans")
(((sound-command set-reverb)) "set-reverb")
(((sound-command set-flava)) "set-flava")
(((sound-command set-language)) "set-language")
(((sound-command reload-info)) "reload-info")
(((sound-command set-sound-falloff)) "set-sound-falloff")
(((sound-command set-falloff-curve)) "set-falloff-curve")
(((sound-command get-irx-version)) "get-irx-version")
(((sound-command continue-group)) "continue-group")
(((sound-command stop-group)) "stop-group")
(((sound-command pause-group)) "pause-group")
(((sound-command set-master-volume)) "set-master-volume")
(((sound-command set-param)) "set-param")
(((sound-command continue-sound)) "continue-sound")
(((sound-command stop-sound)) "stop-sound")
(((sound-command pause-sound)) "pause-sound")
(((sound-command play)) "play")
(((sound-command unload-bank)) "unload-bank")
(((sound-command load-music)) "load-music")
(((sound-command load-bank)) "load-bank")
(else "*unknown*")
)
)
(defun sound-buffer-dump ()
(let ((elt-used (-> *sound-player-rpc* current elt-used))
(elt-size (-> *sound-player-rpc* current elt-size)))
(dotimes (i (the-as int elt-used))
(let* ((cmd (the sound-rpc-play (&+ (-> *sound-player-rpc* current base) (* elt-size (the-as uint i)))))
(a3-0 (sound-command->string (-> cmd command)))
(command (-> cmd command))
)
(if (= command (sound-command play))
(format #t "~D ~A ~G~%" i a3-0 (-> cmd name))
(format #t "~D ~A~%" i a3-0)
)
)
)
)
0
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; sound playback
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define *sound-player-enable* #t)
(defun swap-sound-buffers ((arg0 vector) (arg1 vector) (arg2 float))
(cond
((check-busy *sound-player-rpc*)
(set! *sound-player-enable* #f)
)
(else
(let ((a0-2 (-> *sound-player-rpc* current)))
(if (< (-> a0-2 elt-used) (-> a0-2 elt-count))
(sound-set-ear-trans arg0 arg1 arg2)
)
)
(call *sound-player-rpc* (the-as uint 0) (the-as pointer 0) (the-as uint 0))
(set! *sound-player-enable* #t)
)
)
(cond
((not (is-cd-in?))
(if (or (not *progress-process*)
(!= (-> *progress-process* 0 display-state) 32))
(activate-progress *dproc* 32)
)
)
((not (is-cd-good?))
(if (or (not *progress-process*)
(!= (-> *progress-process* 0 display-state) 33))
(activate-progress *dproc* 33)
)
)
)
0
)
(defun get-sound-buffer-entry ()
(add-element *sound-player-rpc*)
)
(defun free-last-sound-buffer-entry ()
(decrement-elt-used *sound-player-rpc*)
0
)
;; sound-basic-cb
(defun sound-trans-convert ((dest vector3w) (src vector))
(let ((vec (if src src (ear-trans))))
(set! (-> dest x) (the int (* (1/ 16) (-> vec x))))
(set! (-> dest y) (the int (* (1/ 16) (-> vec y))))
(set! (-> dest z) (the int (* (1/ 16) (-> vec z))))
)
0
)
(defun sound-angle-convert ((deg float))
(let ((ret (the int (* (/ 360.0 65536.0) (the float (sar (shl (the int deg) 48) 48))))))
(if (< ret 0)
(+! ret 360)
)
(if (< 359 ret)
(+! ret -360)
)
ret
)
)
(defun string->sound-name ((str string)) (defun string->sound-name ((str string))
(let ((snd-name (new 'stack-no-clear 'qword))) (let ((snd-name (new 'stack-no-clear 'qword)))
(set! (-> snd-name quad) (the-as uint128 0)) (set! (-> snd-name quad) (the-as uint128 0))
@ -25,3 +319,698 @@
(the-as sound-name (-> snd-name quad)) (the-as sound-name (-> snd-name quad))
) )
) )
(defun sound-set-volume ((group uint) (volume float))
(let ((cmd (the sound-rpc-set-master-volume (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command set-master-volume))
(set! (-> cmd group) group)
(set! (-> cmd volume) (the int (* 10.24 volume)))
)
0
)
(defun sound-set-ear-trans ((ear-trans vector) (cam-trans vector) (cam-angle float))
(let ((cmd (the sound-rpc-set-ear-trans (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command set-ear-trans))
(sound-trans-convert (-> cmd ear-trans) ear-trans)
(sound-trans-convert (-> cmd cam-trans) cam-trans)
(set! (-> cmd cam-angle) (sound-angle-convert cam-angle))
)
0
)
(defmacro sound-trans-from-process (cmd sound-trans)
"Macro for getting an appropriate sound-trans from a process-drawable, if possible"
`(begin
(with-pp
(let ((proc (the process-drawable pp)))
(when (= ,sound-trans #t)
(if (and proc
(type-type? (-> proc type) process-drawable)
(nonzero? (-> proc root)))
(set! ,sound-trans (-> proc root trans))
(set! ,sound-trans (the vector #f))
)
)
)
)
(sound-trans-convert (-> ,cmd parms trans) ,sound-trans)
)
)
(defun sound-play-by-name ((name sound-name) (id sound-id) (vol int) (pitch int) (bend int) (group uint) (trans vector))
"Play a sound called name with the specified params"
(let ((sound-trans trans))
(when *sound-player-enable*
(let ((cmd (the sound-rpc-play (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command play))
(set! (-> cmd id) id)
(set! (-> cmd name) name)
(set! (-> cmd parms mask) (the-as uint 0))
(set! (-> cmd parms group) group)
(set! (-> cmd parms volume) vol)
(set! (-> cmd parms pitch-mod) pitch)
(set! (-> cmd parms bend) bend)
(sound-trans-from-process cmd sound-trans)
)
)
)
id
)
(defun sound-play-by-spec ((spec sound-spec) (id sound-id) (sound-trans vector))
"Play a sound from the given spec"
(when *sound-player-enable*
(let ((cmd (the sound-rpc-play (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command play))
(set! (-> cmd id) id)
(set! (-> cmd name) (-> spec sound-name))
(set! (-> cmd parms mask) (-> spec mask))
(set! (-> cmd parms group) (-> spec group))
(set! (-> cmd parms volume) (-> spec volume))
(set! (-> cmd parms pitch-mod) (-> spec pitch-mod))
(set! (-> cmd parms bend) (-> spec bend))
(set! (-> cmd parms fo-min) (-> spec fo-min))
(set! (-> cmd parms fo-max) (-> spec fo-max))
(set! (-> cmd parms fo-curve) (-> spec fo-curve))
(set! (-> cmd parms priority) (-> spec priority))
(sound-trans-from-process cmd sound-trans)
)
)
id
)
(defun sound-pause ((id sound-id))
(let ((cmd (the sound-rpc-pause-sound (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command pause-sound))
(set! (-> cmd id) id)
)
0
)
(defun sound-stop ((id sound-id))
(let ((cmd (the sound-rpc-stop-sound (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command stop-sound))
(set! (-> cmd id) id)
)
0
)
(defun sound-continue ((id sound-id))
(let ((cmd (the sound-rpc-continue-sound (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command continue-sound))
(set! (-> cmd id) id)
)
0
)
(defun sound-group-pause ((group uint))
(let ((cmd (the sound-rpc-pause-group (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command pause-group))
(set! (-> cmd group) group)
)
0
)
(defun sound-group-stop ((group uint))
(let ((cmd (the sound-rpc-stop-group (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command stop-group))
(set! (-> cmd group) group)
)
0
)
(defun sound-group-continue ((group uint))
(let ((cmd (the sound-rpc-continue-group (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command continue-group))
(set! (-> cmd group) group)
)
0
)
(defun sound-set-falloff-curve ((curve int) (falloff float) (ease float))
(let ((cmd (the sound-rpc-set-falloff-curve (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command set-falloff-curve))
(set! (-> cmd curve) curve)
(set! (-> cmd falloff) (the int (* 4096.0 falloff)))
(set! (-> cmd ease) (the int (* 4096.0 ease)))
)
0
)
(defun sound-set-sound-falloff ((name sound-name) (falloff-min int) (falloff-max int) (curve int))
(let ((cmd (the sound-rpc-set-sound-falloff (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command set-sound-falloff))
(set! (-> cmd name) name)
(set! (-> cmd min) falloff-min)
(set! (-> cmd max) falloff-max)
(set! (-> cmd curve) curve)
)
0
)
(defun sound-set-flava ((flava uint))
(let ((cmd (the sound-rpc-set-flava (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command set-flava))
(set! (-> cmd flava) flava)
)
0
)
(define-extern *setting-control* setting-control)
(defun sound-volume-off ()
"Set all sound volume to zero"
(with-pp
(dummy-10 *setting-control* pp 'music-volume 'abs 0.0 0)
(dummy-10 *setting-control* pp 'sfx-volume 'abs 0.0 0)
(dummy-10 *setting-control* pp 'ambient-volume 'abs 0.0 0)
)
0
)
(define *ambient-spec* (new 'static 'sound-spec))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; ambient-sound stuff
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defmethod new ambient-sound ((allocation symbol) (type-to-make type) (src basic) (sound-trans vector))
"Make a new ambient-sound. If failed, returns 0 and doesn't allocate anything.
src specifies the sound params source. This can be a string or symbol (the sound name), a sound-spec, or an entity-actor or entity-ambient (reads effect-name, cycle-speed and effect-param from the entity)."
(let ((spec (the sound-spec #f))
(name (new 'static 'sound-name))
(sound-times (the (pointer float) #f))
(params (the sound-play-parms #f))
(param-count 0)
)
(case (-> src type)
((entity-actor entity-ambient)
(swhen (res-lump-struct-exact (the entity src) 'effect-name symbol)
(set! name (string->sound-name (symbol->string bc)))
(set! sound-times (res-lump-data (the entity src) 'cycle-speed (pointer float)))
(set! spec *ambient-spec*)
(let ((sv-64 (new 'static 'res-tag)))
(swhen (res-lump-data-exact (the entity src) 'effect-param sound-play-parms :tag-ptr (& sv-64))
(set! params bc)
(set! param-count (the int (-> sv-64 elt-count)))
)
)
)
)
((sound-spec)
(set! spec (the sound-spec src))
)
((symbol)
(set! name (string->sound-name (symbol->string (the symbol src))))
)
((string)
(set! name (string->sound-name (the string src)))
)
(else
(format 0 "ERROR: ambient sound was told to play an unknown ~A.~%" src)
)
)
(cond
((or spec (nonzero? name))
(let ((obj (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
(set! (-> obj spec) spec)
(set! (-> obj name) name)
(set! (-> obj playing-id) (new-sound-id))
(set! (-> obj params) params)
(set! (-> obj param-count) param-count)
(set! (-> obj entity) #f)
(set! (-> obj sound-count) 1)
(set! (-> obj volume) 1024)
(set! (-> obj pitch) 0)
(when (and spec (!= spec *ambient-spec*))
(if (nonzero? (logand (-> spec mask) 1))
(set! (-> obj volume) (-> spec volume)))
(if (nonzero? (logand (-> spec mask) 2))
(set! (-> obj pitch) (-> spec pitch-mod)))
)
(cond
(sound-times
(set! (-> obj time-base) (the-as uint (the int (* 300.0 (-> sound-times 0)))))
(set! (-> obj time-random) (the-as uint (the int (* 300.0 (-> sound-times 1)))))
)
(else
(set! (-> obj time-base) (the-as uint -1))
)
)
(set! (-> obj trans quad) (-> sound-trans quad))
obj
)
)
(else
(the ambient-sound 0)
)
)
)
)
(defun-extern effect-param->sound-spec sound-spec sound-play-parms int sound-spec)
(define-extern *debug-effect-control* symbol)
(defmethod dummy-9 ambient-sound ((obj ambient-sound))
(if (not *ambient-sound-class*)
(return (the int #f))
)
(cond
((-> obj spec)
(when (or (< (the-as int (-> obj time-base)) 0)
(>= (the-as int (-> *display* base-frame-counter))
(the-as int (-> obj play-time)))
)
(when (>= (the-as int (-> obj time-base)) 0)
(set! (-> obj play-time) (+ (-> *display* base-frame-counter)
(-> obj time-base)
(the-as uint (rand-vu-int-count (the-as int (-> obj time-random))))
))
(set! (-> obj playing-id) (new-sound-id))
)
(let ((spec (-> obj spec)))
(when (= spec *ambient-spec*)
(set! (-> spec volume) (-> obj volume))
(set! (-> spec pitch-mod) (-> obj pitch))
(set! (-> spec bend) 0)
(set! (-> spec sound-name) (-> obj name))
(set! (-> spec fo-max) (-> obj falloff-far))
(set! (-> spec mask) (the-as uint 0))
(if (-> obj params)
(effect-param->sound-spec spec (-> obj params) (-> obj param-count))
)
)
(if (and (nonzero? (-> spec fo-max))
(< (* 4096.0 (the float (-> spec fo-max)))
(vector-vector-distance (ear-trans) (-> obj trans))))
(return 0)
)
(when (and *debug-effect-control* (>= (the-as int (-> obj time-base)) 0))
(with-pp
(format #t "(~5D) effect sound ~A ~G "
(-> *display* base-frame-counter)
(-> pp name)
(-> spec sound-name-char))
(format #t "volume: ~f pitch-mod: ~f~%"
(* 0.09765625 (the float (-> spec volume)))
(* 0.000656168 (the float (-> spec pitch-mod))))
)
)
(let ((spec-volume (-> spec volume)))
(set! (-> spec volume) (-> obj volume))
(set! (-> obj playing-id) (sound-play-by-spec spec (-> obj playing-id) (-> obj trans)))
(set! (-> spec volume) spec-volume)
)
)
)
)
(else
(cond
((< (the-as int (-> obj time-base)) 0)
(set! (-> obj playing-id) (sound-play-by-name
(-> obj name)
(-> obj playing-id)
(-> obj volume)
(-> obj pitch)
0
(the-as uint 1)
(-> obj trans)))
)
(else
(when (>= (the-as int (-> *display* base-frame-counter))
(the-as int (-> obj play-time)))
(set! (-> obj playing-id) (sound-play-by-name
(-> obj name)
(new-sound-id)
(-> obj volume)
(-> obj pitch)
0
(the-as uint 1)
(-> obj trans)))
(set! (-> obj play-time) (+ (-> *display* base-frame-counter)
(-> obj time-base)
(the-as uint (rand-vu-int-count (the-as int (-> obj time-random))))
))
)
)
)
)
)
0
)
(defmethod stop! ambient-sound ((obj ambient-sound))
"Halt playback of this ambient-sound"
(sound-stop (-> obj playing-id))
0
)
(defmethod dummy-11 ambient-sound ((obj ambient-sound) (sound-trans vector))
(set! (-> obj trans quad) (-> sound-trans quad))
(when (nonzero? (-> obj playing-id))
(let ((cmd (the sound-rpc-set-param (get-sound-buffer-entry))))
(set! (-> cmd command) (sound-command set-param))
(set! (-> cmd id) (-> obj playing-id))
(sound-trans-from-process cmd sound-trans)
(set! (-> cmd parms mask) (the-as uint #x20))
(-> cmd id)
)
)
0
)
(defmethod dummy-10 ambient-sound ((obj ambient-sound) (name sound-name))
(when (not (sound-name= (-> obj name) name))
(stop! obj)
(set! (-> obj playing-id) (new-sound-id))
(set! (-> obj name) name)
)
0
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; sound iop debugging
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun show-iop-info ((buf dma-buffer))
"Display sound channel status in the top left corner"
(dotimes (ch 24)
(draw-string-xy
(if (zero? (-> *sound-iop-info* chinfo ch)) "." "X")
buf (+ (* ch 16) 16) 48 0 1)
)
(dotimes (ch 24)
(draw-string-xy
(if (zero? (-> *sound-iop-info* chinfo (+ ch 24))) "." "X")
buf (+ (* ch 16) 16) 64 0 1)
)
0
)
(defun show-iop-memory ((buf dma-buffer))
(draw-string-xy
(string-format "~8D [~4D]" (-> *sound-iop-info* freemem)
(shr (-> *sound-iop-info* freemem) 10))
buf 32 96 0 1)
(draw-string-xy
(string-format "~8D [~4D]" (-> *sound-iop-info* freemem2)
(shr (-> *sound-iop-info* freemem2) 10))
buf 32 64 0 1)
0
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; sound utils
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun-extern math-camera-pos vector)
(defun-extern target-pos int vector)
(defun-extern camera-pos vector)
(defun ear-trans ()
"Return the trans for the game ear"
(cond
((or (movie?) *external-cam-mode*)
(math-camera-pos)
)
(*target*
(target-pos 0)
)
(else
(camera-pos)
)
)
)
(defun-debug make-sqrt-table ()
"Write the C code for the ??? square root table"
(format #t "static int sqrt_table[256] =~%{~%")
(dotimes (i 256)
(let* ((angle (sqrtf (* 16777216.0 (the float i))))
(angle-rounded (the int (+ 0.5 angle))))
(format #t "~D,~%" angle-rounded)
)
)
(format #t "};~%")
0
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; flava system
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(deftype flava-table-row (structure)
((music symbol :offset-assert 0)
(flava uint8 50 :offset-assert 4) ;; index is some flava event, value is music variation
)
:allow-misaligned :method-count-assert 9
:size-assert #x36
:flag-assert #x900000036
)
(deftype flava-table (basic)
((row flava-table-row 20 :inline :offset-assert 4)
(count int32 :offset-assert 1284)
)
:method-count-assert 9
:size-assert #x508
:flag-assert #x900000508
)
;; make a new flava table with nothing defined
(define *flava-table* (new 'global 'flava-table))
(set! (-> *flava-table* count) 0)
(defun flava-lookup ((music symbol) (n int))
"Return the n'th flava for the specified music"
(dotimes (i (-> *flava-table* count))
(if (= (-> *flava-table* row i music) music)
(return (-> *flava-table* row i flava n))
)
)
0
)
(defmacro flava-table-add (name &rest flavas)
"Add a new music and its flavas to the table"
`(begin
;; append a new music to the flava table
(set! (-> *flava-table* row (-> *flava-table* count) music) ,name)
;; reset this music's flavas
(dotimes (n 50)
(set! (-> *flava-table* row (-> *flava-table* count) flava n) 0)
)
;; increase the music count
;; (this should probably be done after...)
(1+! (-> *flava-table* count))
;; set the flavas or whatever they're called
,@(apply (lambda (x) `(set! (-> *flava-table* row (1- (-> *flava-table* count)) flava ,(first x)) ,(second x))) flavas)
)
)
#| flava events (guesses):
0 :
1 : racer
2 : flutflut
3 : to-maincave
4 : to-snow
5 : sage-green
6 : voicebox
7 : birdlady
8 : mayor
9 : sculptor
10: uncle
11: sage-yellow
12: sage-red
13: sage-blue
14: miners
15: warrior
16: geologist
17: gambler
18: sage-hut
19: dock
20: farmer
21: jungleb-eggtop
22: misty-boat
23: misty-ambush (?)
24: beach-sentinel
25: beach-cannon
26: beach-logs
27: citadel-center
28: robocave
29: robocave-top
30: maincave
31: darkcave
32: snow-ambush (?)
33: snow-cave
34: snow-fort
35: snow-balls
36: levitator
37: swamp-launcher
38: swamp-ambush (?)
39: jungle-temple-exit
40: jungle-lurkerm
41: jungle-temple-top
42: rolling-race
43: ogre-middle
44: ogre-end
45: lavatube-middle
46: lavatube-end
47: finalboss-middle
48: finalboss-end
49: default
|#
;; TODO make enum
(flava-table-add 'village1
(5 2)
(6 6)
(7 4)
(20 5)
(8 7)
(9 8)
(10 9)
(19 10)
(18 3)
)
(flava-table-add 'jungle
(39 1)
(40 2)
(41 3)
)
(flava-table-add 'firecanyon
(1 1)
)
(flava-table-add 'jungleb
(21 1)
)
(flava-table-add 'beach
(7 4)
(24 1)
(25 2)
(26 3)
)
(flava-table-add 'misty
(1 3)
(22 2)
(23 1)
)
(flava-table-add 'village2
(5 1)
(6 2)
(15 3)
(16 4)
(17 5)
(36 6)
)
(flava-table-add 'swamp
(2 4)
(37 2)
(38 3)
)
(flava-table-add 'rolling
(42 1)
)
(flava-table-add 'ogre
(43 1)
(44 2)
)
(flava-table-add 'village3
(3 4)
(4 5)
(5 2)
(6 3)
(14 1)
)
(flava-table-add 'maincave
(28 1)
(29 2)
(30 3)
(31 4)
)
(flava-table-add 'snow
(2 2)
(32 1)
(33 3)
(34 4)
(35 5)
)
(flava-table-add 'lavatube
(45 2)
(46 3)
(49 1)
)
(flava-table-add 'citadel
(5 1)
(6 2)
(11 3)
(12 4)
(13 5)
(27 6)
)
(flava-table-add 'finalboss
(47 1)
(48 2)
)
(flava-table-add 'credits
(49 2)
)

156
goal_src/engine/ui/progress-h.gc
View file

@ -5,7 +5,6 @@
;; name in dgo: progress-h ;; name in dgo: progress-h
;; dgos: GAME, ENGINE ;; dgos: GAME, ENGINE
;; progress-h
(deftype count-info (structure) (deftype count-info (structure)
((money-count int32 :offset-assert 0) ((money-count int32 :offset-assert 0)
(buzzer-count int32 :offset-assert 4) (buzzer-count int32 :offset-assert 4)
@ -16,12 +15,161 @@
:flag-assert #x900000008 :flag-assert #x900000008
) )
;; progress-h
(deftype game-count-info (basic) (deftype game-count-info (basic)
((length int32 :offset-assert 4) ((length int32 :offset-assert 4)
(data count-info :inline :dynamic :offset-assert 8) (data count-info :inline :dynamic :offset-assert 8)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x8 :size-assert #x8
:flag-assert #x900000008 :flag-assert #x900000008
) )
(deftype task-info-data (basic)
((task-id uint8 :offset-assert 4)
(task-name symbol 4 :offset-assert 8)
(text-index-when-resolved int32 :offset-assert 24)
)
:method-count-assert 9
:size-assert #x1c
:flag-assert #x90000001c
)
(deftype level-tasks-info (basic)
((level-name-id uint32 :offset-assert 4)
(text-group-index int32 :offset-assert 8)
(nb-of-tasks int32 :offset-assert 12)
(buzzer-task-index int32 :offset-assert 16)
(task-info task-info-data 8 :offset-assert 20)
)
:method-count-assert 9
:size-assert #x34
:flag-assert #x900000034
)
(deftype game-option (basic)
((option-type uint64 :offset-assert 8)
(name uint32 :offset-assert 16)
(scale basic :offset-assert 20)
(param1 float :offset-assert 24)
(param2 float :offset-assert 28)
(param3 int32 :offset-assert 32)
(value-to-modify uint32 :offset-assert 36)
)
:method-count-assert 9
:size-assert #x28
:flag-assert #x900000028
)
(deftype progress (process)
((current-debug-string int32 :offset-assert 112)
(current-debug-language int32 :offset-assert 116)
(current-debug-group int32 :offset-assert 120)
(in-out-position int32 :offset-assert 124)
(display-state uint64 :offset-assert 128)
(next-display-state uint64 :offset-assert 136)
(option-index int32 :offset-assert 144)
(selected-option basic :offset-assert 148)
(completion-percentage float :offset-assert 152)
(ready-to-run basic :offset-assert 156)
(display-level-index int32 :offset-assert 160)
(next-level-index int32 :offset-assert 164)
(task-index int32 :offset-assert 168)
(in-transition basic :offset-assert 172)
(last-in-transition basic :offset-assert 176)
(force-transition basic :offset-assert 180)
(stat-transition basic :offset-assert 184)
(level-transition int32 :offset-assert 188)
(language-selection uint64 :offset-assert 192)
(language-direction basic :offset-assert 200)
(language-transition basic :offset-assert 204)
(language-x-offset int32 :offset-assert 208)
(sides-x-scale float :offset-assert 212)
(sides-y-scale float :offset-assert 216)
(left-x-offset int32 :offset-assert 220)
(right-x-offset int32 :offset-assert 224)
(button-scale float :offset-assert 228)
(slot-scale float :offset-assert 232)
(left-side-x-scale float :offset-assert 236)
(left-side-y-scale float :offset-assert 240)
(right-side-x-scale float :offset-assert 244)
(right-side-y-scale float :offset-assert 248)
(small-orb-y-offset int32 :offset-assert 252)
(big-orb-y-offset int32 :offset-assert 256)
(transition-offset int32 :offset-assert 260)
(transition-offset-invert int32 :offset-assert 264)
(transition-percentage float :offset-assert 268)
(transition-percentage-invert float :offset-assert 272)
(transition-speed float :offset-assert 276)
(total-nb-of-power-cells int32 :offset-assert 280)
(total-nb-of-orbs int32 :offset-assert 284)
(total-nb-of-buzzers int32 :offset-assert 288)
(card-info mc-slot-info :offset-assert 292)
(last-option-index-change uint64 :offset-assert 296)
(video-mode-timeout uint64 :offset-assert 304)
(display-state-stack uint64 5 :offset-assert 312)
(option-index-stack uint32 5 :offset-assert 352)
(display-state-pos int32 :offset-assert 372)
(nb-of-icons int32 :offset-assert 376)
(icons uint32 6 :offset-assert 380)
(max-nb-of-particles int32 :offset-assert 404)
(nb-of-particles int32 :offset-assert 408)
(particles uint32 40 :offset-assert 412)
(particle-state uint32 40 :offset-assert 572)
)
:method-count-assert 59
:size-assert #x2dc
:flag-assert #x3b000002dc
(:methods
(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)
(dummy-29 () none 29)
(dummy-30 () none 30)
(dummy-31 () none 31)
(dummy-32 () none 32)
(dummy-33 () none 33)
(dummy-34 () none 34)
(dummy-35 () none 35)
(dummy-36 () none 36)
(dummy-37 () none 37)
(dummy-38 () none 38)
(dummy-39 () none 39)
(dummy-40 () none 40)
(dummy-41 () none 41)
(dummy-42 () none 42)
(dummy-43 () none 43)
(dummy-44 () none 44)
(dummy-45 () none 45)
(dummy-46 () none 46)
(dummy-47 () none 47)
(dummy-48 () none 48)
(dummy-49 () none 49)
(dummy-50 () none 50)
(dummy-51 () none 51)
(dummy-52 () none 52)
(dummy-53 () none 53)
(dummy-54 () none 54)
(dummy-55 () none 55)
(dummy-56 () none 56)
(dummy-57 () none 57)
(dummy-58 () none 58)
)
)
(define *progress-process* (the (pointer progress) #f))
(define *progress-last-task-index* 0)
(defun-extern activate-progress process int int)

10
goal_src/goal-lib.gc
View file

@ -343,6 +343,16 @@
) )
) )
(defmacro swhen (condition &rest body)
"Same as when, but saves the branch condition onto a variable named bc"
`(let ((bc ,condition))
(if bc
(begin ,@body)
)
)
)
(defmacro return (val) (defmacro return (val)
`(return-from #f ,val) `(return-from #f ,val)
) )

2
goal_src/kernel-defs.gc
View file

@ -113,7 +113,7 @@
(define-extern mc-check-result (function int)) (define-extern mc-check-result (function int))
;; mc-makefile ;; mc-makefile
;; kset-language (define-extern kset-language (function int int))
(define-extern *debug-segment* symbol) (define-extern *debug-segment* symbol)
(define-extern *enable-method-set* int) (define-extern *enable-method-set* int)

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

@ -907,4 +907,33 @@
:bitfield #t :bitfield #t
:type uint16 :type uint16
(dead 2) (dead 2)
(complete 6)) (complete 6))
(defenum sound-command
:type uint16
(load-bank)
(load-music)
(unload-bank)
(play)
(pause-sound)
(stop-sound)
(continue-sound)
(set-param)
(set-master-volume)
(pause-group)
(stop-group)
(continue-group)
(get-irx-version)
(set-falloff-curve)
(set-sound-falloff)
(reload-info)
(set-language)
(set-flava)
(set-reverb)
(set-ear-trans)
(shutdown)
(list-sounds)
(unload-music)
)
(declare-type entity basic)

22
test/decompiler/reference/engine/draw/drawable-ambient-h_REF.gc
View file

@ -55,15 +55,15 @@
;; definition of type level-hint ;; definition of type level-hint
(deftype level-hint (process) (deftype level-hint (process)
((text-id-to-display uint32 :offset-assert 112) ((text-id-to-display uint32 :offset-assert 112)
(sound-to-play basic :offset-assert 116) (sound-to-play basic :offset-assert 116)
(trans vector :offset-assert 120) (trans vector :offset-assert 120)
(sound-id uint32 :offset-assert 124) (sound-id sound-id :offset-assert 124)
(mode basic :offset-assert 128) (mode basic :offset-assert 128)
(total-time uint64 :offset-assert 136) (total-time uint64 :offset-assert 136)
(total-off-time uint64 :offset-assert 144) (total-off-time uint64 :offset-assert 144)
(last-time uint64 :offset-assert 152) (last-time uint64 :offset-assert 152)
(voicebox uint64 :offset-assert 160) (voicebox uint64 :offset-assert 160)
) )
:heap-base #x40 :heap-base #x40
:method-count-assert 16 :method-count-assert 16
@ -113,3 +113,7 @@
;; failed to figure out what this is: ;; failed to figure out what this is:
(let ((v0-10 0)) (let ((v0-10 0))
) )

48
test/decompiler/reference/engine/game/projectiles-h_REF.gc
View file

@ -3,28 +3,28 @@
;; definition of type projectile ;; definition of type projectile
(deftype projectile (process-drawable) (deftype projectile (process-drawable)
((base-trans vector :inline :offset-assert 176) ((base-trans vector :inline :offset-assert 176)
(target vector :inline :offset-assert 192) (target vector :inline :offset-assert 192)
(target-base vector :inline :offset-assert 208) (target-base vector :inline :offset-assert 208)
(parent-base vector :inline :offset-assert 224) (parent-base vector :inline :offset-assert 224)
(parent-quat vector :inline :offset-assert 240) (parent-quat vector :inline :offset-assert 240)
(base-vector vector :inline :offset-assert 256) (base-vector vector :inline :offset-assert 256)
(timeout uint64 :offset-assert 272) (timeout uint64 :offset-assert 272)
(options uint64 :offset-assert 280) (options uint64 :offset-assert 280)
(last-target uint64 :offset-assert 288) (last-target uint64 :offset-assert 288)
(notify-handle uint64 :offset-assert 296) (notify-handle uint64 :offset-assert 296)
(max-speed float :offset-assert 304) (max-speed float :offset-assert 304)
(max-turn float :offset-assert 308) (max-turn float :offset-assert 308)
(old-dist float 16 :offset-assert 312) (old-dist float 16 :offset-assert 312)
(old-dist-count int32 :offset-assert 376) (old-dist-count int32 :offset-assert 376)
(hits int32 :offset-assert 380) (hits int32 :offset-assert 380)
(max-hits int32 :offset-assert 384) (max-hits int32 :offset-assert 384)
(tween float :offset-assert 388) (tween float :offset-assert 388)
(attack-mode basic :offset-assert 392) (attack-mode basic :offset-assert 392)
(update-velocity basic :offset-assert 396) (update-velocity basic :offset-assert 396)
(counter int32 :offset-assert 400) (counter int32 :offset-assert 400)
(target-count int32 :offset-assert 404) (target-count int32 :offset-assert 404)
(sound-id uint32 :offset-assert 408) (sound-id sound-id :offset-assert 408)
) )
:heap-base #x130 :heap-base #x130
:method-count-assert 29 :method-count-assert 29
@ -118,3 +118,7 @@
;; failed to figure out what this is: ;; failed to figure out what this is:
(let ((v0-6 0)) (let ((v0-6 0))
) )

6
test/decompiler/reference/engine/game/settings-h_REF.gc
View file

@ -152,7 +152,7 @@
(:methods (:methods
(new (symbol type int) _type_ 0) (new (symbol type int) _type_ 0)
(dummy-9 () none 9) (dummy-9 () none 9)
(dummy-10 () none 10) (dummy-10 (_type_ process symbol symbol float int) none 10)
(dummy-11 () none 11) (dummy-11 () none 11)
(dummy-12 () none 12) (dummy-12 () none 12)
(dummy-13 () none 13) (dummy-13 () none 13)
@ -220,3 +220,7 @@
;; failed to figure out what this is: ;; failed to figure out what this is:
(let ((v0-7 0)) (let ((v0-7 0))
) )

14
test/decompiler/reference/engine/math/vector-h_REF.gc
View file

@ -251,7 +251,7 @@
(y int32 :offset 4) (y int32 :offset 4)
(z int32 :offset 8) (z int32 :offset 8)
) )
:method-count-assert 9 :allow-misaligned :method-count-assert 9
:size-assert #xc :size-assert #xc
:flag-assert #x90000000c :flag-assert #x90000000c
) )
@ -259,10 +259,10 @@
;; definition for method 3 of type vector3w ;; definition for method 3 of type vector3w
(defmethod inspect vector3w ((obj vector3w)) (defmethod inspect vector3w ((obj vector3w))
(format #t "[~8x] ~A~%" obj 'vector3w) (format #t "[~8x] ~A~%" obj 'vector3w)
(format #t "~Tdata[3] @ #x~X~%" (-> obj data)) (format #t "~Tdata[3] @ #x~X~%" (&-> obj x))
(format #t "~Tx: ~D~%" (-> obj data 0)) (format #t "~Tx: ~D~%" (-> obj x))
(format #t "~Ty: ~D~%" (-> obj data 1)) (format #t "~Ty: ~D~%" (-> obj y))
(format #t "~Tz: ~D~%" (-> obj data 2)) (format #t "~Tz: ~D~%" (-> obj z))
obj obj
) )
@ -963,3 +963,7 @@
;; definition for symbol *zero-vector*, type vector ;; definition for symbol *zero-vector*, type vector
(define *zero-vector* (new 'static 'vector)) (define *zero-vector* (new 'static 'vector))

131
test/decompiler/reference/engine/sound/gsound-h_REF.gc
View file

@ -22,7 +22,9 @@
;; definition of type sound-name ;; definition of type sound-name
(deftype sound-name (uint128) (deftype sound-name (uint128)
() ((lo uint64 :offset 0 :size 64)
(hi uint64 :offset 64 :size 64)
)
:method-count-assert 9 :method-count-assert 9
:size-assert #x10 :size-assert #x10
:flag-assert #x900000010 :flag-assert #x900000010
@ -30,8 +32,8 @@
;; definition of type sound-rpc-cmd ;; definition of type sound-rpc-cmd
(deftype sound-rpc-cmd (structure) (deftype sound-rpc-cmd (structure)
((rsvd1 uint16 :offset-assert 0) ((rsvd1 uint16 :offset-assert 0)
(command uint16 :offset-assert 2) (command sound-command :offset-assert 2)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x4 :size-assert #x4
@ -48,16 +50,16 @@
;; definition of type sound-play-parms ;; definition of type sound-play-parms
(deftype sound-play-parms (structure) (deftype sound-play-parms (structure)
((mask uint16 :offset-assert 0) ((mask uint16 :offset-assert 0)
(pitch-mod int16 :offset-assert 2) (pitch-mod int16 :offset-assert 2)
(bend int16 :offset-assert 4) (bend int16 :offset-assert 4)
(fo-min int16 :offset-assert 6) (fo-min int16 :offset-assert 6)
(fo-max int16 :offset-assert 8) (fo-max int16 :offset-assert 8)
(fo-curve int8 :offset-assert 10) (fo-curve int8 :offset-assert 10)
(priority int8 :offset-assert 11) (priority int8 :offset-assert 11)
(volume int32 :offset-assert 12) (volume int32 :offset-assert 12)
(trans float 3 :offset-assert 16) (trans vector3w :inline :offset-assert 16)
(group uint8 :offset-assert 28) (group uint8 :offset-assert 28)
) )
:pack-me :pack-me
:method-count-assert 9 :method-count-assert 9
@ -83,7 +85,7 @@
;; definition of type sound-rpc-bank-cmd ;; definition of type sound-rpc-bank-cmd
(deftype sound-rpc-bank-cmd (sound-rpc-cmd) (deftype sound-rpc-bank-cmd (sound-rpc-cmd)
((bank-name uint128 :offset-assert 16) ((bank-name sound-name :offset-assert 16)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x20 :size-assert #x20
@ -102,7 +104,7 @@
;; definition of type sound-rpc-sound-cmd ;; definition of type sound-rpc-sound-cmd
(deftype sound-rpc-sound-cmd (sound-rpc-cmd) (deftype sound-rpc-sound-cmd (sound-rpc-cmd)
((id uint32 :offset-assert 4) ((id sound-id :offset-assert 4)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x8 :size-assert #x8
@ -192,7 +194,7 @@
;; definition of type sound-rpc-play ;; definition of type sound-rpc-play
(deftype sound-rpc-play (sound-rpc-sound-cmd) (deftype sound-rpc-play (sound-rpc-sound-cmd)
((name uint128 :offset-assert 16) ((name sound-name :offset-assert 16)
(parms sound-play-parms :inline :offset-assert 32) (parms sound-play-parms :inline :offset-assert 32)
) )
:method-count-assert 9 :method-count-assert 9
@ -361,9 +363,9 @@
;; definition of type sound-rpc-get-irx-version ;; definition of type sound-rpc-get-irx-version
(deftype sound-rpc-get-irx-version (sound-rpc-cmd) (deftype sound-rpc-get-irx-version (sound-rpc-cmd)
((major uint32 :offset-assert 4) ((major uint32 :offset-assert 4)
(minor uint32 :offset-assert 8) (minor uint32 :offset-assert 8)
(ee-addr uint32 :offset-assert 12) (ee-addr pointer :offset-assert 12)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x10 :size-assert #x10
@ -426,10 +428,10 @@
;; definition of type sound-rpc-set-sound-falloff ;; definition of type sound-rpc-set-sound-falloff
(deftype sound-rpc-set-sound-falloff (sound-rpc-cmd) (deftype sound-rpc-set-sound-falloff (sound-rpc-cmd)
((name uint128 :offset-assert 16) ((name sound-name :offset-assert 16)
(curve int32 :offset-assert 32) (curve int32 :offset-assert 32)
(min int32 :offset-assert 36) (min int32 :offset-assert 36)
(max int32 :offset-assert 40) (max int32 :offset-assert 40)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x2c :size-assert #x2c
@ -494,9 +496,9 @@
;; definition of type sound-rpc-set-ear-trans ;; definition of type sound-rpc-set-ear-trans
(deftype sound-rpc-set-ear-trans (sound-rpc-cmd) (deftype sound-rpc-set-ear-trans (sound-rpc-cmd)
((ear-trans float 3 :offset-assert 4) ((ear-trans vector3w :inline :offset-assert 4)
(cam-trans float 3 :offset-assert 16) (cam-trans vector3w :inline :offset-assert 16)
(cam-angle int32 :offset-assert 28) (cam-angle int32 :offset-assert 28)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x20 :size-assert #x20
@ -678,21 +680,21 @@
;; definition of type sound-spec ;; definition of type sound-spec
(deftype sound-spec (basic) (deftype sound-spec (basic)
((mask uint16 :offset-assert 4) ((mask uint16 :offset-assert 4)
(num float :offset-assert 8) (num float :offset-assert 8)
(group uint8 :offset-assert 12) (group uint8 :offset-assert 12)
(sound-name-char uint8 16 :offset 16) (sound-name-char uint8 16 :offset 16)
(sound-name uint128 :offset 16) (sound-name sound-name :offset 16)
(trans float 4 :offset-assert 32) (trans float 4 :offset-assert 32)
(volume int32 :offset-assert 48) (volume int32 :offset-assert 48)
(pitch-mod int32 :offset-assert 52) (pitch-mod int32 :offset-assert 52)
(bend int32 :offset-assert 56) (bend int32 :offset-assert 56)
(fo-min int16 :offset-assert 60) (fo-min int16 :offset-assert 60)
(fo-max int16 :offset-assert 62) (fo-max int16 :offset-assert 62)
(fo-curve int8 :offset-assert 64) (fo-curve int8 :offset-assert 64)
(priority int8 :offset-assert 65) (priority int8 :offset-assert 65)
(auto-time int32 :offset-assert 68) (auto-time int32 :offset-assert 68)
(auto-from int32 :offset-assert 72) (auto-from int32 :offset-assert 72)
) )
:method-count-assert 9 :method-count-assert 9
:size-assert #x4c :size-assert #x4c
@ -726,32 +728,33 @@
;; definition of type ambient-sound ;; definition of type ambient-sound
(deftype ambient-sound (basic) (deftype ambient-sound (basic)
((spec basic :offset-assert 4) ((spec sound-spec :offset-assert 4)
(playing-id uint32 :offset-assert 8) (playing-id sound-id :offset-assert 8)
(trans vector :inline :offset-assert 16) (trans vector :inline :offset-assert 16)
(name uint128 :offset-assert 32) (name sound-name :offset-assert 32)
(play-time uint64 :offset-assert 48) (play-time uint64 :offset-assert 48)
(time-base uint64 :offset-assert 56) (time-base uint64 :offset-assert 56)
(time-random uint64 :offset-assert 64) (time-random uint64 :offset-assert 64)
(volume int32 :offset-assert 72) (volume int32 :offset-assert 72)
(pitch int32 :offset-assert 76) (pitch int32 :offset-assert 76)
(falloff-near int32 :offset-assert 80) (falloff-near int32 :offset-assert 80)
(falloff-far int32 :offset-assert 84) (falloff-far int32 :offset-assert 84)
(falloff-mode int32 :offset-assert 88) (falloff-mode int32 :offset-assert 88)
(params uint32 :offset-assert 92) (params sound-play-parms :offset-assert 92)
(param-count int32 :offset-assert 96) (param-count int32 :offset-assert 96)
(entity basic :offset-assert 100) (entity entity :offset-assert 100)
(sound-count int32 :offset-assert 104) (sound-count int32 :offset-assert 104)
) )
:method-count-assert 14 :method-count-assert 14
:size-assert #x6c :size-assert #x6c
:flag-assert #xe0000006c :flag-assert #xe0000006c
(:methods (:methods
(dummy-9 () none 9) (new (symbol type basic vector) _type_ 0)
(dummy-10 () none 10) (dummy-9 (_type_) int 9)
(dummy-11 () none 11) (dummy-10 (_type_ sound-name) int 10)
(dummy-12 () none 12) (dummy-11 (_type_ vector) int 11)
(dummy-13 () none 13) (dummy-12 (_type_ int) int 12)
(stop! (_type_) int 13)
) )
) )
@ -787,3 +790,7 @@
;; failed to figure out what this is: ;; failed to figure out what this is:
(let ((v0-65 0)) (let ((v0-65 0))
) )