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

;; definition of type joint-control-channel
(deftype joint-control-channel (structure)
  ((parent           joint-control                                              :offset-assert   0)
   (frame-group      art-joint-anim                                             :offset-assert   4)
   (frame-num        float                                                      :offset-assert   8)
   (dist             meters                                                     :offset-assert  12)
   (num-func         (function joint-control-channel float float float float)   :offset-assert  16)
   (param            float                                                    3 :offset-assert  20)
   (frame-interp     float                                                    2 :offset-assert  32)
   (inspector-amount uint8                                                      :offset-assert  40)
   (command          joint-control-command                                      :offset-assert  48)
   (group-sub-index  int8                                                       :offset-assert  56)
   (group-size       int8                                                       :offset-assert  57)
   (eval-time        uint32                                                     :offset-assert  60)
   )
  :method-count-assert 9
  :size-assert         #x40
  :flag-assert         #x900000040
  )

;; definition for method 3 of type joint-control-channel
(defmethod inspect joint-control-channel ((obj joint-control-channel))
  (when (not obj)
    (set! obj obj)
    (goto cfg-23)
    )
  (format #t "[~8x] ~A~%" obj 'joint-control-channel)
  (format #t "~1Tparent: ~A~%" (-> obj parent))
  (format #t "~1Tframe-group: ~A~%" (-> obj frame-group))
  (format #t "~1Tframe-num: ~f~%" (-> obj frame-num))
  (format #t "~1Tdist: (meters ~m)~%" (-> obj dist))
  (format #t "~1Tnum-func: ~A~%" (-> obj num-func))
  (format #t "~1Tparam[3] @ #x~X~%" (-> obj param))
  (dotimes (s5-0 3)
    (format #t "~T  [~D]~1Tparam: ~`float`P~%" s5-0 (-> obj param s5-0))
    )
  (format #t "~1Tframe-interp[2] @ #x~X~%" (-> obj frame-interp))
  (dotimes (s5-1 2)
    (format #t "~T  [~D]~1Tframe-interp: ~`float`P~%" s5-1 (-> obj frame-interp s5-1))
    )
  (format #t "~1Tinspector-amount: ~D~%" (-> obj inspector-amount))
  (let ((t9-11 format)
        (a0-12 #t)
        (a1-11 "~1Tcommand: #x~X : ~S~%")
        (a2-11 (-> obj command))
        (v1-10 (-> obj command))
        )
    (t9-11 a0-12 a1-11 a2-11 (cond
                               ((= v1-10 (joint-control-command stack1))
                                "stack1"
                                )
                               ((= v1-10 (joint-control-command push))
                                "push"
                                )
                               ((= v1-10 (joint-control-command blend))
                                "blend"
                                )
                               ((= v1-10 (joint-control-command push1))
                                "push1"
                                )
                               ((= v1-10 (joint-control-command float))
                                "float"
                                )
                               ((= v1-10 (joint-control-command stack))
                                "stack"
                                )
                               (else
                                 "*unknown*"
                                 )
                               )
           )
    )
  (format #t "~1Tgroup-sub-index: ~D~%" (-> obj group-sub-index))
  (format #t "~1Tgroup-size: ~D~%" (-> obj group-size))
  (format #t "~1Teval-time: ~D~%" (-> obj eval-time))
  (label cfg-23)
  obj
  )

;; definition of type top-anim-joint-control
(deftype top-anim-joint-control (basic)
  ((process             (pointer process-drawable)   :offset-assert   4)
   (interp-select       uint64                     2 :offset-assert   8)
   (base-anim           basic                        :offset-assert  24)
   (base-anim-speed     float                        :offset-assert  28)
   (base-anim-blend     float                        :offset-assert  32)
   (interp              float                        :offset-assert  36)
   (frame-group         art-joint-anim               :offset-assert  40)
   (frame-group-push    art-joint-anim               :offset-assert  44)
   (frame-num           float                        :offset-assert  48)
   (frame-targ          art-joint-anim               :offset-assert  52)
   (frame-speed         float                        :offset-assert  56)
   (frame-blend         float                        :offset-assert  60)
   (frame-cur-blend     float                        :offset-assert  64)
   (frame-start         float                        :offset-assert  68)
   (frame-post-blend    float                        :offset-assert  72)
   (frame-post-end      float                        :offset-assert  76)
   (frame-push-time     time-frame                   :offset-assert  80)
   (frame-post-put-away basic                        :offset-assert  88)
   (update-time         time-frame                   :offset-assert  96)
   )
  :method-count-assert 13
  :size-assert         #x68
  :flag-assert         #xd00000068
  (:methods
    (new (symbol type process-drawable) _type_ 0)
    (reset (_type_) none 9)
    (update (_type_) none 10)
    (get-channel (_type_ int) joint-control-channel 11)
    (push-anim-to-targ (_type_ art-joint-anim float int int float float symbol) none 12)
    )
  )

;; definition for method 3 of type top-anim-joint-control
(defmethod inspect top-anim-joint-control ((obj top-anim-joint-control))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tprocess: #x~X~%" (-> obj process))
  (format #t "~1Tinterp-select[2] @ #x~X~%" (-> obj interp-select))
  (format #t "~1Tbase-anim: ~A~%" (-> obj base-anim))
  (format #t "~1Tbase-anim-speed: ~f~%" (-> obj base-anim-speed))
  (format #t "~1Tbase-anim-blend: ~f~%" (-> obj base-anim-blend))
  (format #t "~1Tinterp: ~f~%" (-> obj interp))
  (format #t "~1Tframe-group: ~A~%" (-> obj frame-group))
  (format #t "~1Tframe-group-push: ~A~%" (-> obj frame-group-push))
  (format #t "~1Tframe-num: ~f~%" (-> obj frame-num))
  (format #t "~1Tframe-targ: ~A~%" (-> obj frame-targ))
  (format #t "~1Tframe-speed: ~f~%" (-> obj frame-speed))
  (format #t "~1Tframe-blend: ~f~%" (-> obj frame-blend))
  (format #t "~1Tframe-cur-blend: ~f~%" (-> obj frame-cur-blend))
  (format #t "~1Tframe-start: ~f~%" (-> obj frame-start))
  (format #t "~1Tframe-post-blend: ~f~%" (-> obj frame-post-blend))
  (format #t "~1Tframe-post-end: ~f~%" (-> obj frame-post-end))
  (format #t "~1Tframe-push-time: ~D~%" (-> obj frame-push-time))
  (format #t "~1Tframe-post-put-away: ~A~%" (-> obj frame-post-put-away))
  (format #t "~1Tupdate-time: ~D~%" (-> obj update-time))
  (label cfg-4)
  obj
  )

;; definition of type joint-control
(deftype joint-control (basic)
  ((status                  joint-control-status                                                     :offset-assert   4)
   (allocated-length        uint8                                                                    :offset-assert   6)
   (active-channels         uint8                                                                    :offset-assert   7)
   (root-channel            (inline-array joint-control-channel)                                     :offset         16)
   (blend-index             uint8                                                                    :offset-assert  20)
   (active-frame-interp     uint8                                                                    :offset-assert  21)
   (float-channels          uint8                                                                    :offset-assert  22)
   (generate-frame-function (function joint-anim-frame int joint-control int)                        :offset-assert  24)
   (prebind-function        (function joint-anim-frame int joint-control int)                        :offset-assert  28)
   (postbind-function       (function draw-control cspace-array joint-control none)                  :offset-assert  32)
   (effect                  effect-control                                                           :offset-assert  36)
   (interp-select           int64                                                   2                :offset-assert  40)
   (top-anim                top-anim-joint-control                                                   :offset-assert  56)
   (override                (array float)                                                            :offset-assert  60)
   (channel                 joint-control-channel                                   :inline :dynamic :offset-assert  64)
   )
  :method-count-assert 12
  :size-assert         #x40
  :flag-assert         #xc00000040
  (:methods
    (new (symbol type int) _type_ 0)
    (current-cycle-distance (_type_) float 9)
    (update-anim-data (_type_) none 10)
    (debug-print-channels (_type_ symbol) int 11)
    )
  )

;; definition for method 3 of type joint-control
(defmethod inspect joint-control ((obj joint-control))
  (when (not obj)
    (set! obj obj)
    (goto cfg-28)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tstatus: #x~X : (joint-control-status " (-> obj status))
  (let ((s5-0 (-> obj status)))
    (if (= (logand s5-0 (joint-control-status blend-shape)) (joint-control-status blend-shape))
        (format #t "blend-shape ")
        )
    (if (= (logand s5-0 (joint-control-status valid-spooled-frame)) (joint-control-status valid-spooled-frame))
        (format #t "valid-spooled-frame ")
        )
    (if (= (logand s5-0 (joint-control-status spooling-not-last-block))
           (joint-control-status spooling-not-last-block)
           )
        (format #t "spooling-not-last-block ")
        )
    (if (= (logand s5-0 (joint-control-status eye-anim)) (joint-control-status eye-anim))
        (format #t "eye-anim ")
        )
    (if (= (logand s5-0 (joint-control-status math-when-off-screen)) (joint-control-status math-when-off-screen))
        (format #t "math-when-off-screen ")
        )
    (if (= (logand s5-0 (joint-control-status sync-math)) (joint-control-status sync-math))
        (format #t "sync-math ")
        )
    (if (= (logand s5-0 (joint-control-status eye-anim-valid)) (joint-control-status eye-anim-valid))
        (format #t "eye-anim-valid ")
        )
    (if (= (logand s5-0 (joint-control-status blend-shape-valid)) (joint-control-status blend-shape-valid))
        (format #t "blend-shape-valid ")
        )
    (if (= (logand s5-0 (joint-control-status spooling)) (joint-control-status spooling))
        (format #t "spooling ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tallocated-length: ~D~%" (-> obj allocated-length))
  (format #t "~1Tactive-channels: ~D~%" (-> obj active-channels))
  (format #t "~1Troot-channel: #x~X~%" (-> obj root-channel))
  (format #t "~1Tblend-index: ~D~%" (-> obj blend-index))
  (format #t "~1Tactive-frame-interp: ~D~%" (-> obj active-frame-interp))
  (format #t "~1Tfloat-channels: ~D~%" (-> obj float-channels))
  (format #t "~1Tgenerate-frame-function: ~A~%" (-> obj generate-frame-function))
  (format #t "~1Tprebind-function: ~A~%" (-> obj prebind-function))
  (format #t "~1Tpostbind-function: ~A~%" (-> obj postbind-function))
  (format #t "~1Teffect: ~A~%" (-> obj effect))
  (format #t "~1Tinterp-select[2] @ #x~X~%" (-> obj interp-select))
  (dotimes (s5-1 2)
    (format #t "~T  [~D]~1Tinterp-select: ~D~%" s5-1 (-> obj interp-select s5-1))
    )
  (format #t "~1Ttop-anim: ~A~%" (-> obj top-anim))
  (format #t "~1Toverride: ~A~%" (-> obj override))
  (format #t "~1Tchannel[0] @ #x~X~%" (-> obj channel))
  (dotimes (s5-2 (the-as int (-> obj active-channels)))
    (format #t "~T  [~D]~1Tchannel: ~`joint-control-channel`P~%" s5-2 (-> obj channel s5-2))
    )
  (label cfg-28)
  obj
  )

;; definition of type matrix-stack
(deftype matrix-stack (structure)
  ((top  matrix            :offset-assert   0)
   (data matrix 24 :inline :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x610
  :flag-assert         #x900000610
  )

;; definition for method 3 of type matrix-stack
(defmethod inspect matrix-stack ((obj matrix-stack))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'matrix-stack)
  (format #t "~1Ttop: #<matrix @ #x~X>~%" (-> obj top))
  (format #t "~1Tdata[24] @ #x~X~%" (-> obj data))
  (label cfg-4)
  obj
  )

;; definition of type channel-upload-info
(deftype channel-upload-info (structure)
  ((fixed     joint-anim-compressed-fixed  :offset-assert   0)
   (fixed-qwc int32                        :offset-assert   4)
   (frame     joint-anim-compressed-frame  :offset-assert   8)
   (frame-qwc int32                        :offset-assert  12)
   (amount    float                        :offset-assert  16)
   (interp    float                        :offset-assert  20)
   )
  :pack-me
  :method-count-assert 9
  :size-assert         #x18
  :flag-assert         #x900000018
  )

;; definition for method 3 of type channel-upload-info
(defmethod inspect channel-upload-info ((obj channel-upload-info))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'channel-upload-info)
  (format #t "~1Tfixed: #<joint-anim-compressed-fixed @ #x~X>~%" (-> obj fixed))
  (format #t "~1Tfixed-qwc: ~D~%" (-> obj fixed-qwc))
  (format #t "~1Tframe: #<joint-anim-compressed-frame @ #x~X>~%" (-> obj frame))
  (format #t "~1Tframe-qwc: ~D~%" (-> obj frame-qwc))
  (format #t "~1Tamount: ~f~%" (-> obj amount))
  (format #t "~1Tinterp: ~f~%" (-> obj interp))
  (label cfg-4)
  obj
  )

;; definition of type joint-work
(deftype joint-work (structure)
  ((temp-mtx       matrix                      :inline     :offset-assert   0)
   (joint-stack    matrix-stack                :inline     :offset-assert  64)
   (fix-jmp-table  (function none)             16          :offset-assert 1616)
   (frm-jmp-table  (function none)             16          :offset-assert 1680)
   (pair-jmp-table (function none)             16          :offset-assert 1744)
   (uploads        channel-upload-info         24 :inline  :offset-assert 1808)
   (num-uploads    int32                                   :offset-assert 2384)
   (mtx-acc        matrix                      2 :inline   :offset-assert 2400)
   (tq-acc         transformq                  100 :inline :offset-assert 2528)
   (jacp-hdr       joint-anim-compressed-hdr   :inline     :offset-assert 7328)
   (fixed-data     joint-anim-compressed-fixed :inline     :offset-assert 7392)
   (frame-data     joint-anim-compressed-frame 2 :inline   :offset-assert 9600)
   (flatten-array  float                       576         :offset        2400)
   (flattened      vector                      24          :offset        2400)
   )
  :method-count-assert 9
  :size-assert         #x3640
  :flag-assert         #x900003640
  )

;; definition for method 3 of type joint-work
(defmethod inspect joint-work ((obj joint-work))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'joint-work)
  (format #t "~1Ttemp-mtx: #<matrix @ #x~X>~%" (-> obj temp-mtx))
  (format #t "~1Tjoint-stack: #<matrix-stack @ #x~X>~%" (-> obj joint-stack))
  (format #t "~1Tfix-jmp-table[16] @ #x~X~%" (-> obj fix-jmp-table))
  (format #t "~1Tfrm-jmp-table[16] @ #x~X~%" (-> obj frm-jmp-table))
  (format #t "~1Tpair-jmp-table[16] @ #x~X~%" (-> obj pair-jmp-table))
  (format #t "~1Tuploads[24] @ #x~X~%" (-> obj uploads))
  (format #t "~1Tnum-uploads: ~D~%" (-> obj num-uploads))
  (format #t "~1Tmtx-acc[2] @ #x~X~%" (-> obj mtx-acc))
  (format #t "~1Ttq-acc[100] @ #x~X~%" (-> obj tq-acc))
  (format #t "~1Tjacp-hdr: #<joint-anim-compressed-hdr @ #x~X>~%" (-> obj jacp-hdr))
  (format #t "~1Tfixed-data: #<joint-anim-compressed-fixed @ #x~X>~%" (-> obj fixed-data))
  (format #t "~1Tframe-data[2] @ #x~X~%" (-> obj frame-data))
  (format #t "~1Tflatten-array[576] @ #x~X~%" (-> obj mtx-acc))
  (format #t "~1Tflattened[24] @ #x~X~%" (-> obj mtx-acc))
  (label cfg-4)
  obj
  )

;; failed to figure out what this is:
0