jak-project/test/decompiler/reference/jak2/engine/data/art-h_REF.gc

;;-*-Lisp-*-
(in-package goal)

;; definition of type joint-anim
(deftype joint-anim (basic)
  "Base class for all joint animations. These are animations that store joint transforms."
  ((name    string)
   (number  int16)
   (length  int16)
   )
  )

;; definition for method 3 of type joint-anim
(defmethod inspect ((this joint-anim))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tnumber: ~D~%" (-> this number))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (label cfg-4)
  this
  )

;; definition of type joint-anim-matrix
(deftype joint-anim-matrix (joint-anim)
  "Joint animation which stores matrices directly. Not used."
  ((data  matrix  :inline :dynamic :offset  16)
   )
  )

;; definition of type joint-anim-transformq
(deftype joint-anim-transformq (joint-anim)
  "Joint animation which stores transformq's directly. Not used."
  ((data  transformq  :inline :dynamic :offset  16)
   )
  )

;; definition for method 3 of type joint-anim-transformq
(defmethod inspect ((this joint-anim-transformq))
  (when (not this)
    (set! this this)
    (goto cfg-7)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tnumber: ~D~%" (-> this number))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Tdata[0] @ #x~X~%" (-> this data))
  (dotimes (s5-0 (-> this length))
    (format #t "~T  [~D]~1Tdata: ~`transformq`P~%" s5-0 (-> this data s5-0))
    )
  (label cfg-7)
  this
  )

;; definition of type joint-anim-drawable
(deftype joint-anim-drawable (joint-anim)
  "Mysterious unused joint animation type."
  ((data  drawable  :dynamic)
   )
  )

;; definition for method 3 of type joint-anim-drawable
(defmethod inspect ((this joint-anim-drawable))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tnumber: ~D~%" (-> this number))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Tdata[0] @ #x~X~%" (-> this data))
  (label cfg-4)
  this
  )

;; definition of type joint-anim-frame
(deftype joint-anim-frame (structure)
  "Frame containing all joint transforms. Note that there are two special frames: align and prejoint.
The 'align' frame is used for the complicated animation alignment system, which allows the animation to move
a character, among other things. The prejoint is just the root of the skeleton.
The remaining transformq's are the joint transforms you'd expect."
  ((matrices  matrix      2 :inline)
   (data      transformq  :inline :dynamic)
   )
  (:methods
    (new (symbol type int) _type_)
    )
  )

;; definition for method 3 of type joint-anim-frame
(defmethod inspect ((this joint-anim-frame))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'joint-anim-frame)
  (format #t "~1Tmatrices[2] @ #x~X~%" (-> this matrices))
  (format #t "~1Tdata[0] @ #x~X~%" (-> this data))
  (label cfg-4)
  this
  )

;; definition for method 0 of type joint-anim-frame
;; WARN: Return type mismatch structure vs joint-anim-frame.
(defmethod new joint-anim-frame ((allocation symbol) (type-to-make type) (arg0 int))
  (let ((v1-1 (max 0 (+ arg0 -2))))
    (the-as
      joint-anim-frame
      (new-dynamic-structure allocation type-to-make (the-as int (+ (-> type-to-make size) (* 48 v1-1))))
      )
    )
  )

;; definition of type joint-anim-compressed-hdr
(deftype joint-anim-compressed-hdr (structure)
  "Header for the compressed joint animation format."
  ((control-bits  uint32  14)
   (num-joints    uint32)
   (matrix-bits   uint32)
   )
  )

;; definition for method 3 of type joint-anim-compressed-hdr
(defmethod inspect ((this joint-anim-compressed-hdr))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'joint-anim-compressed-hdr)
  (format #t "~1Tcontrol-bits[14] @ #x~X~%" (-> this control-bits))
  (format #t "~1Tnum-joints: ~D~%" (-> this num-joints))
  (format #t "~1Tmatrix-bits: ~D~%" (-> this matrix-bits))
  (label cfg-4)
  this
  )

;; definition of type joint-anim-compressed-fixed
(deftype joint-anim-compressed-fixed (structure)
  ((hdr        joint-anim-compressed-hdr  :inline)
   (offset-64  uint32)
   (offset-32  uint32)
   (offset-16  uint32)
   (reserved   uint32)
   (data       vector                     133 :inline)
   )
  )

;; definition for method 3 of type joint-anim-compressed-fixed
(defmethod inspect ((this joint-anim-compressed-fixed))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'joint-anim-compressed-fixed)
  (format #t "~1Thdr: #<joint-anim-compressed-hdr @ #x~X>~%" (-> this hdr))
  (format #t "~1Toffset-64: ~D~%" (-> this offset-64))
  (format #t "~1Toffset-32: ~D~%" (-> this offset-32))
  (format #t "~1Toffset-16: ~D~%" (-> this offset-16))
  (format #t "~1Treserved: ~D~%" (-> this reserved))
  (format #t "~1Tdata[133] @ #x~X~%" (-> this data))
  (label cfg-4)
  this
  )

;; definition of type joint-anim-compressed-frame
(deftype joint-anim-compressed-frame (structure)
  ((offset-64  uint32)
   (offset-32  uint32)
   (offset-16  uint32)
   (reserved   uint32)
   (data       vector  133 :inline)
   )
  )

;; definition for method 3 of type joint-anim-compressed-frame
(defmethod inspect ((this joint-anim-compressed-frame))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'joint-anim-compressed-frame)
  (format #t "~1Toffset-64: ~D~%" (-> this offset-64))
  (format #t "~1Toffset-32: ~D~%" (-> this offset-32))
  (format #t "~1Toffset-16: ~D~%" (-> this offset-16))
  (format #t "~1Treserved: ~D~%" (-> this reserved))
  (format #t "~1Tdata[133] @ #x~X~%" (-> this data))
  (label cfg-4)
  this
  )

;; definition of type joint-anim-compressed-control
(deftype joint-anim-compressed-control (structure)
  ((num-frames  uint16)
   (flags       uint16)
   (fixed-qwc   uint32)
   (frame-qwc   uint32)
   (fixed       joint-anim-compressed-fixed)
   (data        joint-anim-compressed-frame  :dynamic)
   )
  )

;; definition for method 3 of type joint-anim-compressed-control
(defmethod inspect ((this joint-anim-compressed-control))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'joint-anim-compressed-control)
  (format #t "~1Tnum-frames: ~D~%" (-> this num-frames))
  (format #t "~1Tflags: ~D~%" (-> this flags))
  (format #t "~1Tfixed-qwc: ~D~%" (-> this fixed-qwc))
  (format #t "~1Tframe-qwc: ~D~%" (-> this frame-qwc))
  (format #t "~1Tfixed: #<joint-anim-compressed-fixed @ #x~X>~%" (-> this fixed))
  (format #t "~1Tdata[0] @ #x~X~%" (-> this data))
  (label cfg-4)
  this
  )

;; definition of type art
(deftype art (basic)
  "Base class for anything considered `art`. This is typically foreground model data.
This can be either an art container containing more arts, or an actual art thing (art-element)."
  ((name    string  :offset   8)
   (length  int32)
   (extra   res-lump)
   )
  (:methods
    (login (_type_) _type_)
    (get-art-by-name-method (_type_ string type) basic)
    (get-art-idx-by-name-method (_type_ string type) int)
    (needs-link? (_type_) symbol)
    )
  )

;; definition for method 3 of type art
(defmethod inspect ((this art))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Textra: ~A~%" (-> this extra))
  (label cfg-4)
  this
  )

;; definition of type art-element
(deftype art-element (art)
  "Base class Art which is not a container of more art."
  ((pad  uint8  12)
   )
  )

;; definition for method 3 of type art-element
(defmethod inspect ((this art-element))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Textra: ~A~%" (-> this extra))
  (label cfg-4)
  this
  )

;; definition of type art-mesh-anim
(deftype art-mesh-anim (art-element)
  "An unused mesh animation."
  ((data  basic  :dynamic)
   )
  )

;; definition of type art-joint-anim
(deftype art-joint-anim (art-element)
  "Art for a joint animation. Also contains the eye animation."
  ((speed                   float                :overlay-at (-> pad 0))
   (artist-base             float                :overlay-at (-> pad 4))
   (artist-step             float                :overlay-at (-> pad 8))
   (eye-anim                merc-eye-anim-block  :offset   4)
   (master-art-group-name   string)
   (master-art-group-index  int32)
   (blend-shape-anim        (pointer int8))
   (frames                  joint-anim-compressed-control)
   )
  )

;; definition for method 3 of type art-joint-anim
(defmethod inspect ((this art-joint-anim))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Textra: ~A~%" (-> this extra))
  (format #t "~1Tspeed: ~f~%" (-> this speed))
  (format #t "~1Tartist-base: ~f~%" (-> this artist-base))
  (format #t "~1Tartist-step: ~f~%" (-> this artist-step))
  (format #t "~1Teye-anim: ~A~%" (-> this eye-anim))
  (format #t "~1Tmaster-art-group-name: ~A~%" (-> this master-art-group-name))
  (format #t "~1Tmaster-art-group-index: ~D~%" (-> this master-art-group-index))
  (format #t "~1Tblend-shape-anim: ~A~%" (-> this blend-shape-anim))
  (format #t "~1Tframes: #<joint-anim-compressed-control @ #x~X>~%" (-> this frames))
  (label cfg-4)
  this
  )

;; definition of type art-group
(deftype art-group (art)
  ((info  file-info             :offset   4)
   (data  art-element  :dynamic :offset  32)
   )
  (:methods
    (relocate (_type_ kheap (pointer uint8)) none :replace)
    (link-art! (_type_) art-group)
    (unlink-art! (_type_) int)
    )
  )

;; definition of type art-mesh-geo
(deftype art-mesh-geo (art-element)
  "Unused art format for a mesh. This might have been for the renderer that came before merc."
  ((data  basic  :dynamic)
   )
  )

;; definition of type art-joint-geo
(deftype art-joint-geo (art-element)
  "Collection of joints for an actor."
  ((data  joint  :dynamic)
   )
  )

;; definition of type art-joint-anim-manager-slot
(deftype art-joint-anim-manager-slot (structure)
  "Record for an animation which is additionally compressed with LZO compression over the entire animation.
This is used for short, commonly used animations that always remain in RAM."
  ((anim        art-joint-anim)
   (comp-data   uint32)
   (time-stamp  uint64)
   )
  )

;; definition for method 3 of type art-joint-anim-manager-slot
(defmethod inspect ((this art-joint-anim-manager-slot))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'art-joint-anim-manager-slot)
  (format #t "~1Tanim: ~A~%" (-> this anim))
  (format #t "~1Tcomp-data: #x~X~%" (-> this comp-data))
  (format #t "~1Ttime-stamp: ~D~%" (-> this time-stamp))
  (label cfg-4)
  this
  )

;; definition of type art-joint-anim-manager
(deftype art-joint-anim-manager (basic)
  "Cache for LZO decompression of animations."
  ((kheap       kheap                        :inline)
   (free-index  int32)
   (slot        art-joint-anim-manager-slot  64 :inline)
   )
  (:methods
    (new (symbol type int) _type_)
    (decompress (_type_ art-joint-anim) art-joint-anim)
    (update-time-stamp (_type_ art-joint-anim) art-joint-anim)
    (unload-from-slot (_type_ int) art-joint-anim)
    (used-bytes-for-slot (_type_ int) int)
    (unload-from-level (_type_ level) none)
    )
  )

;; definition for method 3 of type art-joint-anim-manager
(defmethod inspect ((this art-joint-anim-manager))
  (when (not this)
    (set! this this)
    (goto cfg-7)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Theap: #<kheap @ #x~X>~%" (-> this kheap))
  (format #t "~1Tfree-index: ~D~%" (-> this free-index))
  (format #t "~1Tslot[64] @ #x~X~%" (-> this slot))
  (dotimes (s5-0 64)
    (format #t "~T  [~D]~1Tslot: ~`art-joint-anim-manager-slot`P~%" s5-0 (-> this slot s5-0))
    )
  (label cfg-7)
  this
  )

;; definition for method 0 of type art-joint-anim-manager
(defmethod new art-joint-anim-manager ((allocation symbol) (type-to-make type) (arg0 int))
  (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (let ((s4-0 (-> gp-0 kheap)))
      (set! (-> s4-0 base) (kmalloc (the-as kheap (-> allocation value)) arg0 (kmalloc-flags) "heap"))
      (set! (-> s4-0 current) (-> s4-0 base))
      (set! (-> s4-0 top-base) (&+ (-> s4-0 base) arg0))
      (set! (-> s4-0 top) (-> s4-0 top-base))
      )
    (dotimes (v1-6 64)
      (set! (-> gp-0 slot v1-6 anim) #f)
      )
    (set! (-> gp-0 free-index) 0)
    gp-0
    )
  )

;; definition of type skeleton-group
(deftype skeleton-group (art-group)
  "Unlike other art types, the skeleton-groups are defined in GOAL code.
This stores settings like the name of the art-group, shadow/level-of-detail settings, etc."
  ((art-group-name      string)
   (jgeo                int32)
   (janim               int32)
   (bounds              vector  :inline)
   (radius              meters  :overlay-at (-> bounds data 3))
   (mgeo                int16   6)
   (max-lod             int32)
   (lod-dist            float   6)
   (longest-edge        meters)
   (texture-level       int8)
   (version             int8)
   (shadow              int8)
   (sort                int8)
   (origin-joint-index  int8)
   (shadow-joint-index  int8)
   (light-index         uint8)
   (pad                 uint8)
   )
  (:methods
    (add-to-loading-level (_type_) skeleton-group)
    )
  )

;; definition for method 3 of type skeleton-group
(defmethod inspect ((this skeleton-group))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tname: ~A~%" (-> this name))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Textra: ~A~%" (-> this extra))
  (format #t "~1Tinfo: ~A~%" (-> this info))
  (format #t "~1Tdata[0] @ #x~X~%" (&-> this art-group-name))
  (format #t "~1Tart-group-name: ~A~%" (-> this art-group-name))
  (format #t "~1Tjgeo: ~D~%" (-> this jgeo))
  (format #t "~1Tjanim: ~D~%" (-> this janim))
  (format #t "~1Tbounds: ~`vector`P~%" (-> this bounds))
  (format #t "~1Tradius: (meters ~m)~%" (-> this bounds w))
  (format #t "~1Tmgeo[6] @ #x~X~%" (-> this mgeo))
  (format #t "~1Tmax-lod: ~D~%" (-> this max-lod))
  (format #t "~1Tlod-dist[6] @ #x~X~%" (-> this lod-dist))
  (format #t "~1Tlongest-edge: (meters ~m)~%" (-> this longest-edge))
  (format #t "~1Ttexture-level: ~D~%" (-> this texture-level))
  (format #t "~1Tversion: ~D~%" (-> this version))
  (format #t "~1Tshadow: ~D~%" (-> this shadow))
  (format #t "~1Tsort: ~D~%" (-> this sort))
  (format #t "~1Torigin-joint-index: ~D~%" (-> this origin-joint-index))
  (format #t "~1Tshadow-joint-index: ~D~%" (-> this shadow-joint-index))
  (format #t "~1Tlight-index: ~D~%" (-> this light-index))
  (label cfg-4)
  this
  )

;; definition of type lod-group
(deftype lod-group (structure)
  "A single level of detail mesh."
  ((geo   merc-ctrl)
   (dist  meters)
   )
  :pack-me
  )

;; definition for method 3 of type lod-group
(defmethod inspect ((this lod-group))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'lod-group)
  (format #t "~1Tgeo: ~A~%" (-> this geo))
  (format #t "~1Tdist: (meters ~m)~%" (-> this dist))
  (label cfg-4)
  this
  )

;; definition of type lod-set
(deftype lod-set (structure)
  "All the different level-of-detail meshes for an actor."
  ((lod      lod-group  6 :inline)
   (max-lod  int8)
   )
  (:methods
    (setup-lods! (_type_ skeleton-group art-group entity) _type_)
    )
  )

;; definition for method 3 of type lod-set
(defmethod inspect ((this lod-set))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'lod-set)
  (format #t "~1Tlod[6] @ #x~X~%" (-> this lod))
  (format #t "~1Tmax-lod: ~D~%" (-> this max-lod))
  (label cfg-4)
  this
  )

;; definition of type draw-control
(deftype draw-control (basic)
  "The draw-control is a collection of all the stuff that the foreground rendering system needs to draw something.
Each process-drawable has a draw-control."
  ((process               process-drawable)
   (status                draw-control-status)
   (data-format           draw-control-data-format)
   (global-effect         draw-control-global-effect)
   (art-group             art-group)
   (jgeo                  art-joint-geo)
   (mgeo                  merc-ctrl)
   (dma-add-func          (function process-drawable draw-control symbol object none))
   (skeleton              skeleton)
   (lod-set               lod-set  :inline)
   (max-lod               int8     :overlay-at (-> lod-set max-lod))
   (force-lod             int8)
   (cur-lod               int8)
   (desired-lod           int8)
   (ripple                ripple-control)
   (longest-edge          meters)
   (longest-edge?         uint32   :overlay-at longest-edge)
   (light-index           uint8)
   (shadow-mask           uint8)
   (level-index           uint8)
   (death-draw-overlap    uint8)
   (death-timer           uint8)
   (death-timer-org       uint8)
   (death-vertex-skip     uint16)
   (death-effect          uint32)
   (shadow                shadow-geo)
   (shadow-ctrl           shadow-control)
   (distance              meters)
   (origin                vector   :inline)
   (bounds                vector   :inline)
   (radius                meters   :overlay-at (-> bounds data 3))
   (color-mult            rgbaf    :inline)
   (color-emissive        rgbaf    :inline)
   (effect-mask           uint64)
   (seg-mask              uint64)
   (origin-joint-index    uint8)
   (shadow-joint-index    uint8)
   (force-fade            uint8)
   (default-texture-page  uint8)
   (shadow-values         uint32)
   )
  (:methods
    (new (symbol type process symbol) _type_)
    (get-skeleton-origin (_type_) vector)
    (lod-set! (_type_ int) none)
    (lods-assign! (_type_ lod-set) none)
    (setup-masks (_type_ int int) none)
    (setup-cspace-and-add (_type_ art-joint-geo symbol) cspace-array)
    (do-joint-math (_type_ cspace-array joint-control) none)
    )
  )

;; definition for method 3 of type draw-control
(defmethod inspect ((this draw-control))
  (when (not this)
    (set! this this)
    (goto cfg-47)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tprocess: ~A~%" (-> this process))
  (format #t "~1Tstatus: #x~X : (draw-control-status " (-> this status))
  (let ((s5-0 (-> this status)))
    (if (= (logand s5-0 (draw-control-status no-draw-temp)) (draw-control-status no-draw-temp))
        (format #t "no-draw-temp ")
        )
    (if (= (logand s5-0 (draw-control-status lod-set)) (draw-control-status lod-set))
        (format #t "lod-set ")
        )
    (if (= (logand s5-0 (draw-control-status no-draw-bounds2)) (draw-control-status no-draw-bounds2))
        (format #t "no-draw-bounds2 ")
        )
    (if (= (logand s5-0 (draw-control-status math-skel)) (draw-control-status math-skel))
        (format #t "math-skel ")
        )
    (if (= (logand s5-0 (draw-control-status force-vu1)) (draw-control-status force-vu1))
        (format #t "force-vu1 ")
        )
    (if (= (logand s5-0 (draw-control-status warp-cross-fade)) (draw-control-status warp-cross-fade))
        (format #t "warp-cross-fade ")
        )
    (if (= (logand s5-0 (draw-control-status disable-fog)) (draw-control-status disable-fog))
        (format #t "disable-fog ")
        )
    (if (= (logand s5-0 (draw-control-status no-closest-distance)) (draw-control-status no-closest-distance))
        (format #t "no-closest-distance ")
        )
    (if (= (logand s5-0 (draw-control-status hud)) (draw-control-status hud))
        (format #t "hud ")
        )
    (if (= (logand s5-0 (draw-control-status no-draw)) (draw-control-status no-draw))
        (format #t "no-draw ")
        )
    (if (= (logand s5-0 (draw-control-status on-screen)) (draw-control-status on-screen))
        (format #t "on-screen ")
        )
    (if (= (logand s5-0 (draw-control-status close-to-screen)) (draw-control-status close-to-screen))
        (format #t "close-to-screen ")
        )
    (if (= (logand s5-0 (draw-control-status force-fade)) (draw-control-status force-fade))
        (format #t "force-fade ")
        )
    (if (= (logand s5-0 (draw-control-status no-draw-bounds)) (draw-control-status no-draw-bounds))
        (format #t "no-draw-bounds ")
        )
    (if (= (logand s5-0 (draw-control-status uninited)) (draw-control-status uninited))
        (format #t "uninited ")
        )
    )
  (format #t ")~%")
  (let ((t9-19 format)
        (a0-35 #t)
        (a1-19 "~1Tdata-format: #x~X : ~S~%")
        (a2-3 (-> this data-format))
        (v1-47 (-> this data-format))
        )
    (t9-19 a0-35 a1-19 a2-3 (cond
                              ((= v1-47 (draw-control-data-format merc))
                               "merc"
                               )
                              ((= v1-47 (draw-control-data-format pris))
                               "pris"
                               )
                              (else
                                "*unknown*"
                                )
                              )
           )
    )
  (format #t "~1Tglobal-effect: #x~X : (draw-control-global-effect " (-> this global-effect))
  (let ((s5-1 (-> this global-effect)))
    (if (= (logand s5-1 (draw-control-global-effect title-light)) (draw-control-global-effect title-light))
        (format #t "title-light ")
        )
    (if (= (logand s5-1 (draw-control-global-effect bit-1)) (draw-control-global-effect bit-1))
        (format #t "bit-1 ")
        )
    (if (= (logand s5-1 (draw-control-global-effect disable-envmap)) (draw-control-global-effect disable-envmap))
        (format #t "disable-envmap ")
        )
    (if (= (logand s5-1 (draw-control-global-effect bit-0)) (draw-control-global-effect bit-0))
        (format #t "bit-0 ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tart-group: ~A~%" (-> this art-group))
  (format #t "~1Tjgeo: ~A~%" (-> this jgeo))
  (format #t "~1Tmgeo: ~A~%" (-> this mgeo))
  (format #t "~1Tdma-add-func: ~A~%" (-> this dma-add-func))
  (format #t "~1Tskeleton: ~A~%" (-> this skeleton))
  (format #t "~1Tlod-set: #<lod-set @ #x~X>~%" (-> this lod-set))
  (format #t "~1Tlod[6] @ #x~X~%" (-> this lod-set))
  (format #t "~1Tmax-lod: ~D~%" (-> this lod-set max-lod))
  (format #t "~1Tforce-lod: ~D~%" (-> this force-lod))
  (format #t "~1Tcur-lod: ~D~%" (-> this cur-lod))
  (format #t "~1Tdesired-lod: ~D~%" (-> this desired-lod))
  (format #t "~1Tripple: ~A~%" (-> this ripple))
  (format #t "~1Tlongest-edge: (meters ~m)~%" (-> this longest-edge))
  (format #t "~1Tlongest-edge?: ~D~%" (-> this longest-edge))
  (format #t "~1Tlight-index: ~D~%" (-> this light-index))
  (format #t "~1Tshadow-mask: ~D~%" (-> this shadow-mask))
  (format #t "~1Tlevel-index: ~D~%" (-> this level-index))
  (format #t "~1Tdeath-draw-overlap: ~D~%" (-> this death-draw-overlap))
  (format #t "~1Tdeath-timer: ~D~%" (-> this death-timer))
  (format #t "~1Tdeath-timer-org: ~D~%" (-> this death-timer-org))
  (format #t "~1Tdeath-vertex-skip: ~D~%" (-> this death-vertex-skip))
  (format #t "~1Tdeath-effect: ~D~%" (-> this death-effect))
  (format #t "~1Tshadow: ~A~%" (-> this shadow))
  (format #t "~1Tshadow-ctrl: ~A~%" (-> this shadow-ctrl))
  (format #t "~1Tdistance: (meters ~m)~%" (-> this distance))
  (format #t "~1Torigin: ~`vector`P~%" (-> this origin))
  (format #t "~1Tbounds: ~`vector`P~%" (-> this bounds))
  (format #t "~1Tradius: (meters ~m)~%" (-> this bounds w))
  (format #t "~1Tcolor-mult: #<rgbaf @ #x~X>~%" (-> this color-mult))
  (format #t "~1Tcolor-emissive: #<rgbaf @ #x~X>~%" (-> this color-emissive))
  (format #t "~1Teffect-mask: #x~X~%" (-> this effect-mask))
  (format #t "~1Tseg-mask: #x~X~%" (-> this seg-mask))
  (format #t "~1Torigin-joint-index: ~D~%" (-> this origin-joint-index))
  (format #t "~1Tshadow-joint-index: ~D~%" (-> this shadow-joint-index))
  (format #t "~1Tforce-fade: ~D~%" (-> this force-fade))
  (format #t "~1Tdefault-texture-page: ~D~%" (-> this default-texture-page))
  (format #t "~1Tshadow-values: ~D~%" (-> this shadow-values))
  (label cfg-47)
  this
  )

;; definition for method 9 of type draw-control
(defmethod get-skeleton-origin ((this draw-control))
  (-> this skeleton bones 0 transform trans)
  )

;; failed to figure out what this is:
0