mirror of
https://github.com/open-goal/jak-project
synced 2026-06-01 17:58:14 -04:00
water111
6227c6d6a8
also make jak 1 and jak 2 behave the same way, to reduce confusion. It wasn't too bad to update jak 1.
313 lines
13 KiB
Common Lisp
Vendored
Generated
313 lines
13 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type load-dir
|
|
(deftype load-dir (basic)
|
|
((lev level :offset-assert 4)
|
|
(string-array (array string) :offset-assert 8)
|
|
(data-array (array basic) :offset-assert 12)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x10
|
|
:flag-assert #xb00000010
|
|
(:methods
|
|
(new (symbol type int level) _type_ 0)
|
|
(load-to-heap-by-name (_type_ string symbol kheap int) art-group 9)
|
|
(set-loaded-art (_type_ art-group) art-group 10)
|
|
)
|
|
)
|
|
|
|
;; definition of type load-dir-art-group
|
|
(deftype load-dir-art-group (load-dir)
|
|
((art-group-array (array art-group) :offset 12)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x10
|
|
:flag-assert #xb00000010
|
|
(:methods
|
|
(new (symbol type int level) _type_ 0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 0 of type load-dir
|
|
(defmethod new load-dir ((allocation symbol) (type-to-make type) (arg0 int) (arg1 level))
|
|
(let ((s4-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> s4-0 lev) arg1)
|
|
(set! (-> s4-0 string-array)
|
|
(the-as (array string) ((method-of-type array new) allocation array string arg0))
|
|
)
|
|
(set! (-> s4-0 string-array length) 0)
|
|
(set! (-> s4-0 data-array) (the-as (array basic) ((method-of-type array new) allocation array basic arg0)))
|
|
(set! (-> s4-0 data-array length) 0)
|
|
s4-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 0 of type load-dir-art-group
|
|
;; WARN: Return type mismatch load-dir vs load-dir-art-group.
|
|
(defmethod new load-dir-art-group ((allocation symbol) (type-to-make type) (arg0 int) (arg1 level))
|
|
(let ((v0-0 ((method-of-type load-dir new) allocation type-to-make arg0 arg1)))
|
|
(set! (-> v0-0 data-array content-type) art-group)
|
|
(the-as load-dir-art-group v0-0)
|
|
)
|
|
)
|
|
|
|
;; definition of type external-art-buffer
|
|
(deftype external-art-buffer (basic)
|
|
((index int32 :offset-assert 4)
|
|
(other external-art-buffer :offset-assert 8)
|
|
(status symbol :offset-assert 12)
|
|
(locked? symbol :offset-assert 16)
|
|
(login? symbol :offset-assert 20)
|
|
(frame-lock symbol :offset-assert 24)
|
|
(init-heap (function external-art-buffer object) :offset-assert 28)
|
|
(heap kheap :inline :offset-assert 32)
|
|
(pending-load-file string :offset-assert 48)
|
|
(pending-load-file-part int32 :offset-assert 52)
|
|
(pending-load-file-owner handle :offset-assert 56)
|
|
(pending-load-file-priority float :offset-assert 64)
|
|
(load-file string :offset-assert 68)
|
|
(load-file-part int32 :offset-assert 72)
|
|
(load-file-owner handle :offset-assert 80)
|
|
(load-file-priority float :offset-assert 88)
|
|
(buf pointer :offset-assert 92)
|
|
(len int32 :offset-assert 96)
|
|
(art-group art-group :offset-assert 100)
|
|
(art-data uint32 :offset 100)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x68
|
|
:flag-assert #x1000000068
|
|
(:methods
|
|
(new (symbol type int function symbol) _type_ 0)
|
|
(set-pending-file (_type_ string int handle float) int 9)
|
|
(update (_type_) int 10)
|
|
(inactive? (_type_) symbol 11)
|
|
(file-status (_type_ string int) symbol 12)
|
|
(link-file (_type_ art-group) art-group 13)
|
|
(unlink-file (_type_ art-group) int 14)
|
|
(unlock! (_type_) int 15)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type external-art-buffer
|
|
(defmethod inspect external-art-buffer ((obj external-art-buffer))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tindex: ~D~%" (-> obj index))
|
|
(format #t "~1Tother: ~A~%" (-> obj other))
|
|
(format #t "~1Tstatus: ~A~%" (-> obj status))
|
|
(format #t "~1Tlocked?: ~A~%" (-> obj locked?))
|
|
(format #t "~1Tlogin?: ~A~%" (-> obj login?))
|
|
(format #t "~1Tframe-lock: ~A~%" (-> obj frame-lock))
|
|
(format #t "~1Tinit-heap: ~A~%" (-> obj init-heap))
|
|
(format #t "~1Theap: #<kheap @ #x~X>~%" (-> obj heap))
|
|
(format #t "~1Tpending-load-file: ~A~%" (-> obj pending-load-file))
|
|
(format #t "~1Tpending-load-file-part: ~D~%" (-> obj pending-load-file-part))
|
|
(format #t "~1Tpending-load-file-owner: ~D~%" (-> obj pending-load-file-owner))
|
|
(format #t "~1Tpending-load-file-priority: ~f~%" (-> obj pending-load-file-priority))
|
|
(format #t "~1Tload-file: ~A~%" (-> obj load-file))
|
|
(format #t "~1Tload-file-part: ~D~%" (-> obj load-file-part))
|
|
(format #t "~1Tload-file-owner: ~D~%" (-> obj load-file-owner))
|
|
(format #t "~1Tload-file-priority: ~f~%" (-> obj load-file-priority))
|
|
(format #t "~1Tbuf: #x~X~%" (-> obj buf))
|
|
(format #t "~1Tlen: ~D~%" (-> obj len))
|
|
(format #t "~1Tart-group: ~A~%" (-> obj art-group))
|
|
(format #t "~1Tart-data: #x~X~%" (-> obj art-group))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type external-art-buffer
|
|
(defmethod new external-art-buffer ((allocation symbol) (type-to-make type) (arg0 int) (arg1 function) (arg2 symbol))
|
|
(let ((v0-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> v0-0 index) arg0)
|
|
(set! (-> v0-0 init-heap) (the-as (function external-art-buffer object) arg1))
|
|
(set! (-> v0-0 login?) arg2)
|
|
(set! (-> v0-0 load-file) #f)
|
|
(set! (-> v0-0 load-file-part) -1)
|
|
(set! (-> v0-0 load-file-owner) (the-as handle #f))
|
|
(set! (-> v0-0 load-file-priority) 100000000.0)
|
|
(set! (-> v0-0 pending-load-file) #f)
|
|
(set! (-> v0-0 pending-load-file-part) -1)
|
|
(set! (-> v0-0 pending-load-file-owner) (the-as handle #f))
|
|
(set! (-> v0-0 pending-load-file-priority) 100000000.0)
|
|
(set! (-> v0-0 art-group) #f)
|
|
(set! (-> v0-0 status) 'initialize)
|
|
(set! (-> v0-0 locked?) #f)
|
|
(set! (-> v0-0 other) #f)
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition of type spool-anim
|
|
(deftype spool-anim (basic)
|
|
((name string :offset 16)
|
|
(anim-name basic :offset-assert 20)
|
|
(buffer external-art-buffer :offset 20)
|
|
(parts int32 :offset-assert 24)
|
|
(hint-id int32 :offset 24)
|
|
(priority float :offset-assert 28)
|
|
(owner handle :offset-assert 32)
|
|
(command-list pair :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|
|
;; definition for method 3 of type spool-anim
|
|
(defmethod inspect spool-anim ((obj spool-anim))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tanim-name: ~A~%" (-> obj buffer))
|
|
(format #t "~1Tparts: ~D~%" (-> obj parts))
|
|
(format #t "~1Thint-id: ~D~%" (-> obj parts))
|
|
(format #t "~1Tpriority: ~f~%" (-> obj priority))
|
|
(format #t "~1Towner: ~D~%" (-> obj owner))
|
|
(format #t "~1Tcommand-list: ~A~%" (-> obj command-list))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type external-art-control
|
|
(deftype external-art-control (basic)
|
|
((buffer external-art-buffer 2 :offset-assert 4)
|
|
(rec spool-anim 3 :inline :offset-assert 16)
|
|
(spool-lock handle :offset-assert 160)
|
|
(reserve-buffer external-art-buffer :offset-assert 168)
|
|
(reserve-buffer-count int16 :offset-assert 172)
|
|
(dma-reserve-buffer-count int16 :offset-assert 174)
|
|
(active-stream string :offset-assert 176)
|
|
(queue-stream (array spool-anim) :offset-assert 180)
|
|
(frame-mask uint32 :offset-assert 184)
|
|
(dma-reserve-heap kheap :inline :offset-assert 192)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xd0
|
|
:flag-assert #x10000000d0
|
|
(:methods
|
|
(new (symbol type) _type_ 0)
|
|
(update (_type_ symbol) int 9)
|
|
(clear-rec (_type_) int 10)
|
|
(spool-push (_type_ string int process float) int 11)
|
|
(file-status (_type_ string int) symbol 12)
|
|
(reserve-alloc (_type_) kheap 13)
|
|
(reserve-free (_type_ kheap) int 14)
|
|
(none-reserved? (_type_) symbol 15)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type external-art-control
|
|
(defmethod inspect external-art-control ((obj external-art-control))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tbuffer[2] @ #x~X~%" (-> obj buffer))
|
|
(format #t "~1Trec[3] @ #x~X~%" (-> obj rec))
|
|
(format #t "~1Tspool-lock: ~D~%" (-> obj spool-lock))
|
|
(format #t "~1Treserve-buffer: ~A~%" (-> obj reserve-buffer))
|
|
(format #t "~1Treserve-buffer-count: ~D~%" (-> obj reserve-buffer-count))
|
|
(format #t "~1Tdma-reserve-buffer-count: ~D~%" (-> obj dma-reserve-buffer-count))
|
|
(format #t "~1Tactive-stream: ~A~%" (-> obj active-stream))
|
|
(format #t "~1Tqueue-stream: ~A~%" (-> obj queue-stream))
|
|
(format #t "~1Tframe-mask: ~D~%" (-> obj frame-mask))
|
|
(format #t "~1Tdma-reserve-heap: #<kheap @ #x~X>~%" (-> obj dma-reserve-heap))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type external-art-control
|
|
(defmethod new external-art-control ((allocation symbol) (type-to-make type))
|
|
(let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(dotimes (s4-0 2)
|
|
(set! (-> gp-0 buffer s4-0)
|
|
((method-of-type external-art-buffer new) allocation external-art-buffer s4-0 external-art-buffer-init #t)
|
|
)
|
|
)
|
|
(set! (-> gp-0 buffer 0 other) (-> gp-0 buffer 1))
|
|
(set! (-> gp-0 buffer 1 other) (-> gp-0 buffer 0))
|
|
(dotimes (v1-9 3)
|
|
(set! (-> gp-0 rec v1-9 name) #f)
|
|
(set! (-> gp-0 rec v1-9 priority) 100000000.0)
|
|
(set! (-> gp-0 rec v1-9 owner) (the-as handle #f))
|
|
)
|
|
(set! (-> gp-0 spool-lock) (the-as handle #f))
|
|
(set! (-> gp-0 reserve-buffer) #f)
|
|
(set! (-> gp-0 active-stream) #f)
|
|
(set! (-> gp-0 queue-stream) (new 'global 'boxed-array spool-anim 4))
|
|
(dotimes (s5-1 (-> gp-0 queue-stream allocated-length))
|
|
(set! (-> gp-0 queue-stream s5-1) (new 'global 'spool-anim))
|
|
)
|
|
(set! (-> gp-0 queue-stream length) 0)
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition of type subtitle-range
|
|
(deftype subtitle-range (basic)
|
|
((start-frame float :offset-assert 4)
|
|
(end-frame float :offset-assert 8)
|
|
(message object 8 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|
|
;; definition for method 3 of type subtitle-range
|
|
(defmethod inspect subtitle-range ((obj subtitle-range))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-7)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tstart-frame: ~f~%" (-> obj start-frame))
|
|
(format #t "~1Tend-frame: ~f~%" (-> obj end-frame))
|
|
(format #t "~1Tmessage[8] @ #x~X~%" (-> obj message))
|
|
(dotimes (s5-0 8)
|
|
(format #t "~T [~D]~1Tmessage: ~`object`P~%" s5-0 (-> obj message s5-0))
|
|
)
|
|
(label cfg-7)
|
|
obj
|
|
)
|
|
|
|
;; definition of type subtitle-image
|
|
(deftype subtitle-image (basic)
|
|
((width uint16 :offset-assert 4)
|
|
(height uint16 :offset-assert 6)
|
|
(palette rgba 16 :offset 16)
|
|
(data uint8 :dynamic :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|
|
;; definition for method 3 of type subtitle-image
|
|
(defmethod inspect subtitle-image ((obj subtitle-image))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Twidth: ~D~%" (-> obj width))
|
|
(format #t "~1Theight: ~D~%" (-> obj height))
|
|
(format #t "~1Tpalette[16] @ #x~X~%" (-> obj palette))
|
|
(format #t "~1Tdata[0] @ #x~X~%" (-> obj data))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
0
|