mirror of
https://github.com/open-goal/jak-project
synced 2026-08-19 06:02:15 -04:00
water111
dbc266c00b
* begin work on improved pretty printer * update ref * finish pretty printer * force line break for defstate
815 lines
31 KiB
Common Lisp
Vendored
Generated
815 lines
31 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type ocean-corner
|
|
(deftype ocean-corner (structure)
|
|
((bsphere sphere :inline :offset-assert 0)
|
|
(start-corner vector :inline :offset-assert 16)
|
|
(y-scales vector :inline :offset-assert 32)
|
|
(alphas vector :inline :offset-assert 48)
|
|
(colors uint32 4 :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-corner
|
|
(defmethod inspect ocean-corner ((obj ocean-corner))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-corner)
|
|
(format #t "~Tbsphere: #<sphere @ #x~X>~%" (-> obj bsphere))
|
|
(format #t "~Tstart-corner: #<vector @ #x~X>~%" (-> obj start-corner))
|
|
(format #t "~Ty-scales: #<vector @ #x~X>~%" (-> obj y-scales))
|
|
(format #t "~Talphas: #<vector @ #x~X>~%" (-> obj alphas))
|
|
(format #t "~Tcolors[4] @ #x~X~%" (-> obj colors))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-wave-info
|
|
(deftype ocean-wave-info (structure)
|
|
((frequency float :offset-assert 0)
|
|
(amplitude float :offset-assert 4)
|
|
(wave-speed float :offset-assert 8)
|
|
(angle float :offset-assert 12)
|
|
(kx float :offset-assert 16)
|
|
(ky float :offset-assert 20)
|
|
(w float :offset-assert 24)
|
|
(flags int32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-wave-info
|
|
(defmethod inspect ocean-wave-info ((obj ocean-wave-info))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-wave-info)
|
|
(format #t "~Tfrequency: ~f~%" (-> obj frequency))
|
|
(format #t "~Tamplitude: ~f~%" (-> obj amplitude))
|
|
(format #t "~Twave-speed: ~f~%" (-> obj wave-speed))
|
|
(format #t "~Tangle: ~f~%" (-> obj angle))
|
|
(format #t "~Tkx: ~f~%" (-> obj kx))
|
|
(format #t "~Tky: ~f~%" (-> obj ky))
|
|
(format #t "~Tw: ~f~%" (-> obj w))
|
|
(format #t "~Tflags: ~D~%" (-> obj flags))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-vertex
|
|
(deftype ocean-vertex (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(stq vector :inline :offset-assert 16)
|
|
(col vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-vertex
|
|
(defmethod inspect ocean-vertex ((obj ocean-vertex))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-vertex)
|
|
(format #t "~Tpos: #<vector @ #x~X>~%" (-> obj pos))
|
|
(format #t "~Tstq: #<vector @ #x~X>~%" (-> obj stq))
|
|
(format #t "~Tcol: #<vector @ #x~X>~%" (-> obj col))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-spheres
|
|
(deftype ocean-spheres (structure)
|
|
((spheres sphere 36 :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x240
|
|
:flag-assert #x900000240
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-spheres
|
|
(defmethod inspect ocean-spheres ((obj ocean-spheres))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-spheres)
|
|
(format #t "~Tspheres[36] @ #x~X~%" (-> obj spheres))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-colors
|
|
(deftype ocean-colors (structure)
|
|
((colors rgba 2548 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x27d0
|
|
:flag-assert #x9000027d0
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-colors
|
|
(defmethod inspect ocean-colors ((obj ocean-colors))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-colors)
|
|
(format #t "~Tcolors[2548] @ #x~X~%" (-> obj colors))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-mid-mask
|
|
(deftype ocean-mid-mask (structure)
|
|
((mask uint8 8 :offset-assert 0)
|
|
(dword uint64 :offset 0)
|
|
)
|
|
:pack-me
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-mid-mask
|
|
(defmethod inspect ocean-mid-mask ((obj ocean-mid-mask))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-mid-mask)
|
|
(format #t "~Tmask[8] @ #x~X~%" (-> obj mask))
|
|
(format #t "~Tdword: #x~X~%" (-> obj dword))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-mid-indices
|
|
(deftype ocean-mid-indices (basic)
|
|
((data uint16 36 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-mid-indices
|
|
(defmethod inspect ocean-mid-indices ((obj ocean-mid-indices))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tdata[36] @ #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-mid-masks
|
|
(deftype ocean-mid-masks (basic)
|
|
((data (inline-array ocean-mid-mask) :offset-assert 4)
|
|
)
|
|
:pack-me
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-mid-masks
|
|
(defmethod inspect ocean-mid-masks ((obj ocean-mid-masks))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tdata: #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-trans-mask
|
|
(deftype ocean-trans-mask (structure)
|
|
((mask uint8 4 :offset-assert 0)
|
|
(word uint64 :offset 0)
|
|
)
|
|
:pack-me
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-trans-mask
|
|
(defmethod inspect ocean-trans-mask ((obj ocean-trans-mask))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-trans-mask)
|
|
(format #t "~Tmask[4] @ #x~X~%" (-> obj mask))
|
|
(format #t "~Tword: #x~X~%" (-> obj word))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-trans-index
|
|
(deftype ocean-trans-index (structure)
|
|
((parent int16 :offset-assert 0)
|
|
(child int16 :offset-assert 2)
|
|
)
|
|
:pack-me
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-trans-index
|
|
(defmethod inspect ocean-trans-index ((obj ocean-trans-index))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-trans-index)
|
|
(format #t "~Tparent: ~D~%" (-> obj parent))
|
|
(format #t "~Tchild: ~D~%" (-> obj child))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-trans-indices
|
|
(deftype ocean-trans-indices (basic)
|
|
((data ocean-trans-index 2304 :inline :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2404
|
|
:flag-assert #x900002404
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-trans-indices
|
|
(defmethod inspect ocean-trans-indices ((obj ocean-trans-indices))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tdata[2304] @ #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-near-index
|
|
(deftype ocean-near-index (structure)
|
|
((data uint16 16 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-near-index
|
|
(defmethod inspect ocean-near-index ((obj ocean-near-index))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-near-index)
|
|
(format #t "~Tdata[16] @ #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-near-indices
|
|
(deftype ocean-near-indices (basic)
|
|
((data (inline-array ocean-near-index) :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-near-indices
|
|
(defmethod inspect ocean-near-indices ((obj ocean-near-indices))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tdata: #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-near-colors
|
|
(deftype ocean-near-colors (structure)
|
|
((color0 vector :inline :offset-assert 0)
|
|
(color1 vector :inline :offset-assert 16)
|
|
(color2 vector :inline :offset-assert 32)
|
|
(color3 vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-near-colors
|
|
(defmethod inspect ocean-near-colors ((obj ocean-near-colors))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-near-colors)
|
|
(format #t "~Tcolor0: #<vector @ #x~X>~%" (-> obj color0))
|
|
(format #t "~Tcolor1: #<vector @ #x~X>~%" (-> obj color1))
|
|
(format #t "~Tcolor2: #<vector @ #x~X>~%" (-> obj color2))
|
|
(format #t "~Tcolor3: #<vector @ #x~X>~%" (-> obj color3))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-map
|
|
(deftype ocean-map (basic)
|
|
((start-corner vector :inline :offset-assert 16)
|
|
(far-color vector :inline :offset-assert 32)
|
|
(ocean-spheres ocean-spheres :offset-assert 48)
|
|
(ocean-colors ocean-colors :offset-assert 52)
|
|
(ocean-mid-indices ocean-mid-indices :offset-assert 56)
|
|
(ocean-trans-indices ocean-trans-indices :offset-assert 60)
|
|
(ocean-near-indices ocean-near-indices :offset-assert 64)
|
|
(ocean-mid-masks ocean-mid-masks :offset-assert 68)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-map
|
|
(defmethod inspect ocean-map ((obj ocean-map))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tstart-corner: #<vector @ #x~X>~%" (-> obj start-corner))
|
|
(format #t "~Tfar-color: #<vector @ #x~X>~%" (-> obj far-color))
|
|
(format #t "~Tocean-spheres: #<ocean-spheres @ #x~X>~%" (-> obj ocean-spheres))
|
|
(format #t "~Tocean-colors: #<ocean-colors @ #x~X>~%" (-> obj ocean-colors))
|
|
(format #t "~Tocean-mid-indices: ~A~%" (-> obj ocean-mid-indices))
|
|
(format #t "~Tocean-trans-indices: ~A~%" (-> obj ocean-trans-indices))
|
|
(format #t "~Tocean-near-indices: ~A~%" (-> obj ocean-near-indices))
|
|
(format #t "~Tocean-mid-masks: ~A~%" (-> obj ocean-mid-masks))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-trans-strip
|
|
(deftype ocean-trans-strip (structure)
|
|
((verts uint128 10 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa0
|
|
:flag-assert #x9000000a0
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-trans-strip
|
|
(defmethod inspect ocean-trans-strip ((obj ocean-trans-strip))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-trans-strip)
|
|
(format #t "~Tverts[10] @ #x~X~%" (-> obj verts))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-trans-strip-array
|
|
(deftype ocean-trans-strip-array (structure)
|
|
((data ocean-trans-strip 4 :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x280
|
|
:flag-assert #x900000280
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-trans-strip-array
|
|
(defmethod inspect ocean-trans-strip-array ((obj ocean-trans-strip-array))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-trans-strip-array)
|
|
(format #t "~Tdata[4] @ #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-wave-data
|
|
(deftype ocean-wave-data (structure)
|
|
((data uint8 1024 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x400
|
|
:flag-assert #x900000400
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-wave-data
|
|
(defmethod inspect ocean-wave-data ((obj ocean-wave-data))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-wave-data)
|
|
(format #t "~Tdata[1024] @ #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-wave-frames
|
|
(deftype ocean-wave-frames (structure)
|
|
((frame ocean-wave-data 64 :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10000
|
|
:flag-assert #x900000000
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-wave-frames
|
|
(defmethod inspect ocean-wave-frames ((obj ocean-wave-frames))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-wave-frames)
|
|
(format #t "~Tframe[64] @ #x~X~%" (-> obj frame))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-work
|
|
(deftype ocean-work (basic)
|
|
((deltas vector :inline :offset-assert 16)
|
|
(map-min vector :inline :offset-assert 32)
|
|
(map-max vector :inline :offset-assert 48)
|
|
(interp vector :inline :offset-assert 64)
|
|
(corner-array ocean-corner 25 :inline :offset-assert 80)
|
|
(corner-count int32 :offset-assert 2080)
|
|
(temp-vecs vector 4 :inline :offset-assert 2096)
|
|
(mid-mask-ptrs (pointer int32) 36 :offset-assert 2160)
|
|
(mid-camera-masks uint64 36 :offset-assert 2304)
|
|
(trans-mask-ptrs (pointer int32) 64 :offset-assert 2592)
|
|
(trans-camera-masks ocean-trans-mask 16 :inline :offset-assert 2848)
|
|
(trans-temp-masks ocean-trans-mask 16 :inline :offset-assert 2976)
|
|
(near-mask-indices uint16 16 :offset-assert 3104)
|
|
(mid-minx uint8 :offset-assert 3136)
|
|
(mid-maxx uint8 :offset-assert 3137)
|
|
(mid-minz uint8 :offset-assert 3138)
|
|
(mid-maxz uint8 :offset-assert 3139)
|
|
(near-minx uint8 :offset-assert 3140)
|
|
(near-maxx uint8 :offset-assert 3141)
|
|
(near-minz uint8 :offset-assert 3142)
|
|
(near-maxz uint8 :offset-assert 3143)
|
|
(temp-minx uint8 :offset-assert 3144)
|
|
(temp-maxx uint8 :offset-assert 3145)
|
|
(temp-minz uint8 :offset-assert 3146)
|
|
(temp-maxz uint8 :offset-assert 3147)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc4c
|
|
:flag-assert #x900000c4c
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-work
|
|
(defmethod inspect ocean-work ((obj ocean-work))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tdeltas: #<vector @ #x~X>~%" (-> obj deltas))
|
|
(format #t "~Tmap-min: #<vector @ #x~X>~%" (-> obj map-min))
|
|
(format #t "~Tmap-max: #<vector @ #x~X>~%" (-> obj map-max))
|
|
(format #t "~Tinterp: #<vector @ #x~X>~%" (-> obj interp))
|
|
(format #t "~Tcorner-array[25] @ #x~X~%" (-> obj corner-array))
|
|
(format #t "~Tcorner-count: ~D~%" (-> obj corner-count))
|
|
(format #t "~Ttemp-vecs[4] @ #x~X~%" (-> obj temp-vecs))
|
|
(format #t "~Tmid-mask-ptrs[36] @ #x~X~%" (-> obj mid-mask-ptrs))
|
|
(format #t "~Tmid-camera-masks[36] @ #x~X~%" (-> obj mid-camera-masks))
|
|
(format #t "~Ttrans-mask-ptrs[64] @ #x~X~%" (-> obj trans-mask-ptrs))
|
|
(format #t "~Ttrans-camera-masks[16] @ #x~X~%" (-> obj trans-camera-masks))
|
|
(format #t "~Ttrans-temp-masks[16] @ #x~X~%" (-> obj trans-temp-masks))
|
|
(format #t "~Tnear-mask-indices[16] @ #x~X~%" (-> obj near-mask-indices))
|
|
(format #t "~Tmid-minx: ~D~%" (-> obj mid-minx))
|
|
(format #t "~Tmid-maxx: ~D~%" (-> obj mid-maxx))
|
|
(format #t "~Tmid-minz: ~D~%" (-> obj mid-minz))
|
|
(format #t "~Tmid-maxz: ~D~%" (-> obj mid-maxz))
|
|
(format #t "~Tnear-minx: ~D~%" (-> obj near-minx))
|
|
(format #t "~Tnear-maxx: ~D~%" (-> obj near-maxx))
|
|
(format #t "~Tnear-minz: ~D~%" (-> obj near-minz))
|
|
(format #t "~Tnear-maxz: ~D~%" (-> obj near-maxz))
|
|
(format #t "~Ttemp-minx: ~D~%" (-> obj temp-minx))
|
|
(format #t "~Ttemp-maxx: ~D~%" (-> obj temp-maxx))
|
|
(format #t "~Ttemp-minz: ~D~%" (-> obj temp-minz))
|
|
(format #t "~Ttemp-maxz: ~D~%" (-> obj temp-maxz))
|
|
obj
|
|
)
|
|
|
|
;; definition for symbol *ocean-work*, type ocean-work
|
|
(define *ocean-work* (new 'static 'ocean-work))
|
|
|
|
;; definition for symbol *ocean-facing*, type int
|
|
(define *ocean-facing* 0)
|
|
|
|
;; definition for symbol *ocean-off*, type symbol
|
|
(define *ocean-off* #f)
|
|
|
|
;; definition for symbol *ocean-mid-off*, type symbol
|
|
(define *ocean-mid-off* #f)
|
|
|
|
;; definition for symbol *ocean-near-off*, type symbol
|
|
(define *ocean-near-off* #f)
|
|
|
|
;; definition for symbol *ocean-heights*, type ocean-wave-info
|
|
(define *ocean-heights* (the-as ocean-wave-info #f))
|
|
|
|
;; definition for symbol *ocean-verts*, type (pointer vector)
|
|
(define *ocean-verts* (the-as (pointer vector) #f))
|
|
|
|
;; definition of type ocean-vu0-work
|
|
(deftype ocean-vu0-work (structure)
|
|
((scales vector :inline :offset-assert 0)
|
|
(mask-hi vector4w :inline :offset-assert 16)
|
|
(mask-lo vector4w :inline :offset-assert 32)
|
|
(lights vu-lights :inline :offset-assert 48)
|
|
(wait-to-vu0 uint32 :offset-assert 160)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa4
|
|
:flag-assert #x9000000a4
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-vu0-work
|
|
(defmethod inspect ocean-vu0-work ((obj ocean-vu0-work))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-vu0-work)
|
|
(format #t "~Tscales: #<vector @ #x~X>~%" (-> obj scales))
|
|
(format #t "~Tmask-hi: #<vector4w @ #x~X>~%" (-> obj mask-hi))
|
|
(format #t "~Tmask-lo: #<vector4w @ #x~X>~%" (-> obj mask-lo))
|
|
(format #t "~Tlights: #<vu-lights @ #x~X>~%" (-> obj lights))
|
|
(format #t "~Twait-to-vu0: ~D~%" (-> obj wait-to-vu0))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-texture-constants
|
|
(deftype ocean-texture-constants (structure)
|
|
((giftag qword :inline :offset-assert 0)
|
|
(buffers vector4w :inline :offset-assert 16)
|
|
(dests vector4w :inline :offset-assert 32)
|
|
(start vector :inline :offset-assert 48)
|
|
(offsets vector :inline :offset-assert 64)
|
|
(constants vector :inline :offset-assert 80)
|
|
(cam-nrm vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-texture-constants
|
|
(defmethod inspect ocean-texture-constants ((obj ocean-texture-constants))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-texture-constants)
|
|
(format #t "~Tgiftag: #<qword @ #x~X>~%" (-> obj giftag))
|
|
(format #t "~Tbuffers: #<vector4w @ #x~X>~%" (-> obj buffers))
|
|
(format #t "~Tdests: #<vector4w @ #x~X>~%" (-> obj dests))
|
|
(format #t "~Tstart: #<vector @ #x~X>~%" (-> obj start))
|
|
(format #t "~Toffsets: #<vector @ #x~X>~%" (-> obj offsets))
|
|
(format #t "~Tconstants: #<vector @ #x~X>~%" (-> obj constants))
|
|
(format #t "~Tcam-nrm: #<vector @ #x~X>~%" (-> obj cam-nrm))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-texture-work
|
|
(deftype ocean-texture-work (structure)
|
|
((sprite-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(sprite-tmpl2 dma-gif-packet :inline :offset-assert 32)
|
|
(adgif-tmpl dma-gif-packet :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-texture-work
|
|
(defmethod inspect ocean-texture-work ((obj ocean-texture-work))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-texture-work)
|
|
(format #t "~Tsprite-tmpl: #<dma-gif-packet @ #x~X>~%" (-> obj sprite-tmpl))
|
|
(format #t "~Tsprite-tmpl2: #<dma-gif-packet @ #x~X>~%" (-> obj sprite-tmpl2))
|
|
(format #t "~Tadgif-tmpl: #<dma-gif-packet @ #x~X>~%" (-> obj adgif-tmpl))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-mid-vertex
|
|
(deftype ocean-mid-vertex (structure)
|
|
((stq vector :inline :offset-assert 0)
|
|
(col vector :inline :offset-assert 16)
|
|
(pos vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-mid-vertex
|
|
(defmethod inspect ocean-mid-vertex ((obj ocean-mid-vertex))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-mid-vertex)
|
|
(format #t "~Tstq: #<vector @ #x~X>~%" (-> obj stq))
|
|
(format #t "~Tcol: #<vector @ #x~X>~%" (-> obj col))
|
|
(format #t "~Tpos: #<vector @ #x~X>~%" (-> obj pos))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-mid-constants
|
|
(deftype ocean-mid-constants (structure)
|
|
((hmge-scale vector :inline :offset-assert 0)
|
|
(inv-hmge-scale vector :inline :offset-assert 16)
|
|
(hvdf-offset vector :inline :offset-assert 32)
|
|
(fog vector :inline :offset-assert 48)
|
|
(constants vector :inline :offset-assert 64)
|
|
(constants2 vector :inline :offset-assert 80)
|
|
(drw-fan qword :inline :offset-assert 96)
|
|
(env-fan qword :inline :offset-assert 112)
|
|
(drw-adgif qword :inline :offset-assert 128)
|
|
(drw-texture adgif-shader :inline :offset-assert 144)
|
|
(drw-strip-0 qword :inline :offset-assert 224)
|
|
(drw-strip-1 qword :inline :offset-assert 240)
|
|
(env-adgif qword :inline :offset-assert 256)
|
|
(env-texture adgif-shader :inline :offset-assert 272)
|
|
(env-strip qword :inline :offset-assert 352)
|
|
(env-color vector :inline :offset-assert 368)
|
|
(index-table uint128 8 :offset-assert 384)
|
|
(pos0 vector :inline :offset-assert 512)
|
|
(pos1 vector :inline :offset-assert 528)
|
|
(pos2 vector :inline :offset-assert 544)
|
|
(pos3 vector :inline :offset-assert 560)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x240
|
|
:flag-assert #x900000240
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-mid-constants
|
|
(defmethod inspect ocean-mid-constants ((obj ocean-mid-constants))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-mid-constants)
|
|
(format #t "~Thmge-scale: #<vector @ #x~X>~%" (-> obj hmge-scale))
|
|
(format #t "~Tinv-hmge-scale: #<vector @ #x~X>~%" (-> obj inv-hmge-scale))
|
|
(format #t "~Thvdf-offset: #<vector @ #x~X>~%" (-> obj hvdf-offset))
|
|
(format #t "~Tfog: #<vector @ #x~X>~%" (-> obj fog))
|
|
(format #t "~Tconstants: #<vector @ #x~X>~%" (-> obj constants))
|
|
(format #t "~Tconstants2: #<vector @ #x~X>~%" (-> obj constants2))
|
|
(format #t "~Tdrw-fan: #<qword @ #x~X>~%" (-> obj drw-fan))
|
|
(format #t "~Tenv-fan: #<qword @ #x~X>~%" (-> obj env-fan))
|
|
(format #t "~Tdrw-adgif: #<qword @ #x~X>~%" (-> obj drw-adgif))
|
|
(format #t "~Tdrw-texture: #<adgif-shader @ #x~X>~%" (-> obj drw-texture))
|
|
(format #t "~Tdrw-strip-0: #<qword @ #x~X>~%" (-> obj drw-strip-0))
|
|
(format #t "~Tdrw-strip-1: #<qword @ #x~X>~%" (-> obj drw-strip-1))
|
|
(format #t "~Tenv-adgif: #<qword @ #x~X>~%" (-> obj env-adgif))
|
|
(format #t "~Tenv-texture: #<adgif-shader @ #x~X>~%" (-> obj env-texture))
|
|
(format #t "~Tenv-strip: #<qword @ #x~X>~%" (-> obj env-strip))
|
|
(format #t "~Tenv-color: #<vector @ #x~X>~%" (-> obj env-color))
|
|
(format #t "~Tindex-table[8] @ #x~X~%" (-> obj index-table))
|
|
(format #t "~Tpos0: #<vector @ #x~X>~%" (-> obj pos0))
|
|
(format #t "~Tpos1: #<vector @ #x~X>~%" (-> obj pos1))
|
|
(format #t "~Tpos2: #<vector @ #x~X>~%" (-> obj pos2))
|
|
(format #t "~Tpos3: #<vector @ #x~X>~%" (-> obj pos3))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-mid-upload
|
|
(deftype ocean-mid-upload (structure)
|
|
((rot matrix :inline :offset-assert 0)
|
|
(matrix matrix :inline :offset-assert 64)
|
|
(colors uint128 108 :offset-assert 128)
|
|
(masks uint128 2 :offset-assert 1856)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x760
|
|
:flag-assert #x900000760
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-mid-upload
|
|
(defmethod inspect ocean-mid-upload ((obj ocean-mid-upload))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-mid-upload)
|
|
(format #t "~Trot: #<matrix @ #x~X>~%" (-> obj rot))
|
|
(format #t "~Tmatrix: #<matrix @ #x~X>~%" (-> obj matrix))
|
|
(format #t "~Tcolors[108] @ #x~X~%" (-> obj colors))
|
|
(format #t "~Tmasks[2] @ #x~X~%" (-> obj masks))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-mid-upload2
|
|
(deftype ocean-mid-upload2 (structure)
|
|
((rot matrix :inline :offset-assert 0)
|
|
(matrix matrix :inline :offset-assert 64)
|
|
(count vector4w :inline :offset-assert 128)
|
|
(tex0 vector :inline :offset-assert 144)
|
|
(tex1 vector :inline :offset-assert 160)
|
|
(tex2 vector :inline :offset-assert 176)
|
|
(tex3 vector :inline :offset-assert 192)
|
|
(clr0 vector :inline :offset-assert 208)
|
|
(clr1 vector :inline :offset-assert 224)
|
|
(clr2 vector :inline :offset-assert 240)
|
|
(clr3 vector :inline :offset-assert 256)
|
|
(verts uint128 18 :offset-assert 272)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x230
|
|
:flag-assert #x900000230
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-mid-upload2
|
|
(defmethod inspect ocean-mid-upload2 ((obj ocean-mid-upload2))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-mid-upload2)
|
|
(format #t "~Trot: #<matrix @ #x~X>~%" (-> obj rot))
|
|
(format #t "~Tmatrix: #<matrix @ #x~X>~%" (-> obj matrix))
|
|
(format #t "~Tcount: #<vector4w @ #x~X>~%" (-> obj count))
|
|
(format #t "~Ttex0: #<vector @ #x~X>~%" (-> obj tex0))
|
|
(format #t "~Ttex1: #<vector @ #x~X>~%" (-> obj tex1))
|
|
(format #t "~Ttex2: #<vector @ #x~X>~%" (-> obj tex2))
|
|
(format #t "~Ttex3: #<vector @ #x~X>~%" (-> obj tex3))
|
|
(format #t "~Tclr0: #<vector @ #x~X>~%" (-> obj clr0))
|
|
(format #t "~Tclr1: #<vector @ #x~X>~%" (-> obj clr1))
|
|
(format #t "~Tclr2: #<vector @ #x~X>~%" (-> obj clr2))
|
|
(format #t "~Tclr3: #<vector @ #x~X>~%" (-> obj clr3))
|
|
(format #t "~Tverts[18] @ #x~X~%" (-> obj verts))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-mid-work
|
|
(deftype ocean-mid-work (structure)
|
|
((env0 vector :inline :offset-assert 0)
|
|
(env1 vector :inline :offset-assert 16)
|
|
(env2 vector :inline :offset-assert 32)
|
|
(hmg0 vector :inline :offset-assert 48)
|
|
(hmg1 vector :inline :offset-assert 64)
|
|
(hmg2 vector :inline :offset-assert 80)
|
|
(indices uint128 16 :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x160
|
|
:flag-assert #x900000160
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-mid-work
|
|
(defmethod inspect ocean-mid-work ((obj ocean-mid-work))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-mid-work)
|
|
(format #t "~Tenv0: #<vector @ #x~X>~%" (-> obj env0))
|
|
(format #t "~Tenv1: #<vector @ #x~X>~%" (-> obj env1))
|
|
(format #t "~Tenv2: #<vector @ #x~X>~%" (-> obj env2))
|
|
(format #t "~Thmg0: #<vector @ #x~X>~%" (-> obj hmg0))
|
|
(format #t "~Thmg1: #<vector @ #x~X>~%" (-> obj hmg1))
|
|
(format #t "~Thmg2: #<vector @ #x~X>~%" (-> obj hmg2))
|
|
(format #t "~Tindices[16] @ #x~X~%" (-> obj indices))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-near-constants
|
|
(deftype ocean-near-constants (structure)
|
|
((hmge-scale vector :inline :offset-assert 0)
|
|
(inv-hmge-scale vector :inline :offset-assert 16)
|
|
(hvdf-offset vector :inline :offset-assert 32)
|
|
(fog vector :inline :offset-assert 48)
|
|
(constants vector :inline :offset-assert 64)
|
|
(constants2 vector :inline :offset-assert 80)
|
|
(constants3 vector :inline :offset-assert 96)
|
|
(constants4 vector :inline :offset-assert 112)
|
|
(drw-fan qword :inline :offset-assert 128)
|
|
(drw2-fan qword :inline :offset-assert 144)
|
|
(env-fan qword :inline :offset-assert 160)
|
|
(drw-adgif qword :inline :offset-assert 176)
|
|
(drw-texture adgif-shader :inline :offset-assert 192)
|
|
(drw-strip qword :inline :offset-assert 272)
|
|
(env-adgif qword :inline :offset-assert 288)
|
|
(env-texture adgif-shader :inline :offset-assert 304)
|
|
(env-strip qword :inline :offset-assert 384)
|
|
(env-color vector :inline :offset-assert 400)
|
|
(drw2-adgif qword :inline :offset-assert 416)
|
|
(drw2-tex0 qword :inline :offset-assert 432)
|
|
(drw2-frame qword :inline :offset-assert 448)
|
|
(drw2-strip qword :inline :offset-assert 464)
|
|
(drw3-adgif qword :inline :offset-assert 480)
|
|
(drw3-frame qword :inline :offset-assert 496)
|
|
(index-table uint128 4 :offset-assert 512)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x240
|
|
:flag-assert #x900000240
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-near-constants
|
|
(defmethod inspect ocean-near-constants ((obj ocean-near-constants))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-near-constants)
|
|
(format #t "~Thmge-scale: #<vector @ #x~X>~%" (-> obj hmge-scale))
|
|
(format #t "~Tinv-hmge-scale: #<vector @ #x~X>~%" (-> obj inv-hmge-scale))
|
|
(format #t "~Thvdf-offset: #<vector @ #x~X>~%" (-> obj hvdf-offset))
|
|
(format #t "~Tfog: #<vector @ #x~X>~%" (-> obj fog))
|
|
(format #t "~Tconstants: #<vector @ #x~X>~%" (-> obj constants))
|
|
(format #t "~Tconstants2: #<vector @ #x~X>~%" (-> obj constants2))
|
|
(format #t "~Tconstants3: #<vector @ #x~X>~%" (-> obj constants3))
|
|
(format #t "~Tconstants4: #<vector @ #x~X>~%" (-> obj constants4))
|
|
(format #t "~Tdrw-fan: #<qword @ #x~X>~%" (-> obj drw-fan))
|
|
(format #t "~Tdrw2-fan: #<qword @ #x~X>~%" (-> obj drw2-fan))
|
|
(format #t "~Tenv-fan: #<qword @ #x~X>~%" (-> obj env-fan))
|
|
(format #t "~Tdrw-adgif: #<qword @ #x~X>~%" (-> obj drw-adgif))
|
|
(format #t "~Tdrw-texture: #<adgif-shader @ #x~X>~%" (-> obj drw-texture))
|
|
(format #t "~Tdrw-strip: #<qword @ #x~X>~%" (-> obj drw-strip))
|
|
(format #t "~Tenv-adgif: #<qword @ #x~X>~%" (-> obj env-adgif))
|
|
(format #t "~Tenv-texture: #<adgif-shader @ #x~X>~%" (-> obj env-texture))
|
|
(format #t "~Tenv-strip: #<qword @ #x~X>~%" (-> obj env-strip))
|
|
(format #t "~Tenv-color: #<vector @ #x~X>~%" (-> obj env-color))
|
|
(format #t "~Tdrw2-adgif: #<qword @ #x~X>~%" (-> obj drw2-adgif))
|
|
(format #t "~Tdrw2-tex0: #<qword @ #x~X>~%" (-> obj drw2-tex0))
|
|
(format #t "~Tdrw2-frame: #<qword @ #x~X>~%" (-> obj drw2-frame))
|
|
(format #t "~Tdrw2-strip: #<qword @ #x~X>~%" (-> obj drw2-strip))
|
|
(format #t "~Tdrw3-adgif: #<qword @ #x~X>~%" (-> obj drw3-adgif))
|
|
(format #t "~Tdrw3-frame: #<qword @ #x~X>~%" (-> obj drw3-frame))
|
|
(format #t "~Tindex-table[4] @ #x~X~%" (-> obj index-table))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-near-upload
|
|
(deftype ocean-near-upload (structure)
|
|
((rot matrix :inline :offset-assert 0)
|
|
(matrix matrix :inline :offset-assert 64)
|
|
(masks uint128 2 :offset-assert 128)
|
|
(start-height vector4w :inline :offset-assert 160)
|
|
(start-st vector :inline :offset-assert 176)
|
|
(near-colors ocean-near-colors :inline :offset-assert 192)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x100
|
|
:flag-assert #x900000100
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-near-upload
|
|
(defmethod inspect ocean-near-upload ((obj ocean-near-upload))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-near-upload)
|
|
(format #t "~Trot: #<matrix @ #x~X>~%" (-> obj rot))
|
|
(format #t "~Tmatrix: #<matrix @ #x~X>~%" (-> obj matrix))
|
|
(format #t "~Tmasks[2] @ #x~X~%" (-> obj masks))
|
|
(format #t "~Tstart-height: #<vector4w @ #x~X>~%" (-> obj start-height))
|
|
(format #t "~Tstart-st: #<vector @ #x~X>~%" (-> obj start-st))
|
|
(format #t "~Tnear-colors: #<ocean-near-colors @ #x~X>~%" (-> obj near-colors))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-near-vertex
|
|
(deftype ocean-near-vertex (structure)
|
|
((stq vector :inline :offset-assert 0)
|
|
(clr vector :inline :offset-assert 16)
|
|
(pos vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-near-vertex
|
|
(defmethod inspect ocean-near-vertex ((obj ocean-near-vertex))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-near-vertex)
|
|
(format #t "~Tstq: #<vector @ #x~X>~%" (-> obj stq))
|
|
(format #t "~Tclr: #<vector @ #x~X>~%" (-> obj clr))
|
|
(format #t "~Tpos: #<vector @ #x~X>~%" (-> obj pos))
|
|
obj
|
|
)
|
|
|
|
;; definition of type ocean-near-work
|
|
(deftype ocean-near-work (structure)
|
|
((verts-ptr vector :inline :offset-assert 0)
|
|
(indices uint128 16 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x110
|
|
:flag-assert #x900000110
|
|
)
|
|
|
|
;; definition for method 3 of type ocean-near-work
|
|
(defmethod inspect ocean-near-work ((obj ocean-near-work))
|
|
(format #t "[~8x] ~A~%" obj 'ocean-near-work)
|
|
(format #t "~Tverts-ptr: #<vector @ #x~X>~%" (-> obj verts-ptr))
|
|
(format #t "~Tindices[16] @ #x~X~%" (-> obj indices))
|
|
obj
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
0
|