;;-*-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 int64)  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 (inline-array vector)
(define *ocean-verts* (the-as (inline-array 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    gs-gif-tag :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        gs-gif-tag   :inline   :offset-assert  96)
   (env-fan        gs-gif-tag   :inline   :offset-assert 112)
   (drw-adgif      gs-gif-tag   :inline   :offset-assert 128)
   (drw-texture    adgif-shader :inline   :offset-assert 144)
   (drw-strip-0    gs-gif-tag   :inline   :offset-assert 224)
   (drw-strip-1    gs-gif-tag   :inline   :offset-assert 240)
   (env-adgif      gs-gif-tag   :inline   :offset-assert 256)
   (env-texture    adgif-shader :inline   :offset-assert 272)
   (env-strip      gs-gif-tag   :inline   :offset-assert 352)
   (env-color      vector       :inline   :offset-assert 368)
   (index-table    vector4w     8 :inline :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        gs-gif-tag   :inline   :offset-assert 128)
   (drw2-fan       gs-gif-tag   :inline   :offset-assert 144)
   (env-fan        gs-gif-tag   :inline   :offset-assert 160)
   (drw-adgif      gs-gif-tag   :inline   :offset-assert 176)
   (drw-texture    adgif-shader :inline   :offset-assert 192)
   (drw-strip      gs-gif-tag   :inline   :offset-assert 272)
   (env-adgif      gs-gif-tag   :inline   :offset-assert 288)
   (env-texture    adgif-shader :inline   :offset-assert 304)
   (env-strip      gs-gif-tag   :inline   :offset-assert 384)
   (env-color      vector       :inline   :offset-assert 400)
   (drw2-adgif     gs-gif-tag   :inline   :offset-assert 416)
   (drw2-tex0      qword        :inline   :offset-assert 432)
   (drw2-frame     qword        :inline   :offset-assert 448)
   (drw2-strip     gs-gif-tag   :inline   :offset-assert 464)
   (drw3-adgif     gs-gif-tag   :inline   :offset-assert 480)
   (drw3-frame     qword        :inline   :offset-assert 496)
   (index-table    vector4w     4 :inline :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
