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

;; definition of type joint-control-channel
(deftype joint-control-channel (structure)
  "A single animation channel that controls a number of joints.
Multiple channels are used to blend animations together."
  ((parent            joint-control)
   (frame-group       art-joint-anim)
   (frame-num         float)
   (dist              meters)
   (num-func          (function joint-control-channel float float float float))
   (param             float  3)
   (frame-interp      float  2)
   (inspector-amount  uint8)
   (command           joint-control-command)
   (group-sub-index   int8)
   (group-size        int8)
   (eval-time         uint32)
   )
  )

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

;; definition of type top-anim-joint-control
(deftype top-anim-joint-control (basic)
  ((process              (pointer process-drawable))
   (interp-select        uint64  2)
   (base-anim            basic)
   (base-anim-speed      float)
   (base-anim-blend      float)
   (interp               float)
   (frame-group          art-joint-anim)
   (frame-group-push     art-joint-anim)
   (frame-num            float)
   (frame-targ           art-joint-anim)
   (frame-speed          float)
   (frame-blend          float)
   (frame-cur-blend      float)
   (frame-start          float)
   (frame-post-blend     float)
   (frame-post-end       float)
   (frame-push-time      time-frame)
   (frame-post-put-away  basic)
   (update-time          time-frame)
   )
  (:methods
    (new (symbol type process-drawable) _type_)
    (reset (_type_) none)
    (update (_type_) none)
    (get-channel (_type_ int) joint-control-channel)
    (push-anim-to-targ (_type_ art-joint-anim float int int float float symbol) none)
    )
  )

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

;; definition of type joint-control
(deftype joint-control (basic)
  "Every [[process-drawable]] has a [[joint-control]] that handles all the animation channels."
  ((status                   joint-control-status)
   (allocated-length         uint8)
   (active-channels          uint8)
   (root-channel             (inline-array joint-control-channel)  :offset  16)
   (blend-index              uint8)
   (active-frame-interp      uint8)
   (float-channels           uint8)
   (generate-frame-function  (function joint-anim-frame int joint-control int))
   (prebind-function         (function joint-anim-frame int joint-control int))
   (postbind-function        (function draw-control cspace-array joint-control none))
   (effect                   effect-control)
   (interp-select            int64                                 2)
   (top-anim                 top-anim-joint-control)
   (override                 (array float))
   (channel                  joint-control-channel                 :inline :dynamic)
   )
  (:methods
    (new (symbol type int) _type_)
    (current-cycle-distance (_type_) float)
    (update-anim-data (_type_) none)
    (debug-print-channels (_type_ symbol) int)
    )
  )

;; definition for method 3 of type joint-control
(defmethod inspect ((this joint-control))
  (when (not this)
    (set! this this)
    (goto cfg-28)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tstatus: #x~X : (joint-control-status " (-> this status))
  (let ((s5-0 (-> this 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~%" (-> this allocated-length))
  (format #t "~1Tactive-channels: ~D~%" (-> this active-channels))
  (format #t "~1Troot-channel: #x~X~%" (-> this root-channel))
  (format #t "~1Tblend-index: ~D~%" (-> this blend-index))
  (format #t "~1Tactive-frame-interp: ~D~%" (-> this active-frame-interp))
  (format #t "~1Tfloat-channels: ~D~%" (-> this float-channels))
  (format #t "~1Tgenerate-frame-function: ~A~%" (-> this generate-frame-function))
  (format #t "~1Tprebind-function: ~A~%" (-> this prebind-function))
  (format #t "~1Tpostbind-function: ~A~%" (-> this postbind-function))
  (format #t "~1Teffect: ~A~%" (-> this effect))
  (format #t "~1Tinterp-select[2] @ #x~X~%" (-> this interp-select))
  (dotimes (s5-1 2)
    (format #t "~T  [~D]~1Tinterp-select: ~D~%" s5-1 (-> this interp-select s5-1))
    )
  (format #t "~1Ttop-anim: ~A~%" (-> this top-anim))
  (format #t "~1Toverride: ~A~%" (-> this override))
  (format #t "~1Tchannel[0] @ #x~X~%" (-> this channel))
  (dotimes (s5-2 (the-as int (-> this active-channels)))
    (format #t "~T  [~D]~1Tchannel: ~`joint-control-channel`P~%" s5-2 (-> this channel s5-2))
    )
  (label cfg-28)
  this
  )

;; definition of type matrix-stack
(deftype matrix-stack (structure)
  ((top   matrix)
   (data  matrix  24 :inline)
   )
  )

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

;; definition of type channel-upload-info
(deftype channel-upload-info (structure)
  "Information about an upload of animation data to a single joint channel."
  ((fixed      joint-anim-compressed-fixed)
   (fixed-qwc  int32)
   (frame      joint-anim-compressed-frame)
   (frame-qwc  int32)
   (amount     float)
   (interp     float)
   )
  :pack-me
  )

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

;; definition of type joint-work
(deftype joint-work (structure)
  ((temp-mtx        matrix                       :inline)
   (joint-stack     matrix-stack                 :inline)
   (fix-jmp-table   (function none)              16)
   (frm-jmp-table   (function none)              16)
   (pair-jmp-table  (function none)              16)
   (uploads         channel-upload-info          24 :inline)
   (num-uploads     int32)
   (mtx-acc         matrix                       2 :inline)
   (tq-acc          transformq                   100 :inline)
   (jacp-hdr        joint-anim-compressed-hdr    :inline)
   (fixed-data      joint-anim-compressed-fixed  :inline)
   (frame-data      joint-anim-compressed-frame  2 :inline)
   (flatten-array   float                        576 :overlay-at mtx-acc)
   (flattened       vector                       24  :overlay-at mtx-acc)
   )
  )

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

;; failed to figure out what this is:
0