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

;; definition of type cam-index
(deftype cam-index (structure)
  ((flags cam-index-options           :offset-assert   0)
   (vec   vector            2 :inline :offset-assert  16)
   )
  :method-count-assert 11
  :size-assert         #x30
  :flag-assert         #xb00000030
  (:methods
    (cam-index-method-9 (_type_ symbol entity vector curve) symbol 9)
    (cam-index-method-10 (_type_ vector) float 10)
    )
  )

;; definition for method 3 of type cam-index
(defmethod inspect cam-index ((obj cam-index))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'cam-index)
  (format #t "~1Tflags: ~D~%" (-> obj flags))
  (format #t "~1Tvec[2] @ #x~X~%" (-> obj vec))
  (label cfg-4)
  obj
  )

;; definition of type tracking-point
(deftype tracking-point (structure)
  ((position    vector :inline :offset-assert   0)
   (direction   vector :inline :offset-assert  16)
   (tp-length   float          :offset-assert  32)
   (next        int32          :offset-assert  36)
   (incarnation int32          :offset-assert  40)
   )
  :method-count-assert 9
  :size-assert         #x2c
  :flag-assert         #x90000002c
  )

;; definition for method 3 of type tracking-point
(defmethod inspect tracking-point ((obj tracking-point))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'tracking-point)
  (format #t "~1Tposition: #<vector @ #x~X>~%" (-> obj position))
  (format #t "~1Tdirection: #<vector @ #x~X>~%" (-> obj direction))
  (format #t "~1Ttp-length: ~f~%" (-> obj tp-length))
  (format #t "~1Tnext: ~D~%" (-> obj next))
  (format #t "~1Tincarnation: ~D~%" (-> obj incarnation))
  (label cfg-4)
  obj
  )

;; definition of type tracking-spline-sampler
(deftype tracking-spline-sampler (structure)
  ((cur-pt     int32  :offset-assert   0)
   (partial-pt float  :offset-assert   4)
   )
  :method-count-assert 9
  :size-assert         #x8
  :flag-assert         #x900000008
  )

;; definition for method 3 of type tracking-spline-sampler
(defmethod inspect tracking-spline-sampler ((obj tracking-spline-sampler))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'tracking-spline-sampler)
  (format #t "~1Tcur-pt: ~D~%" (-> obj cur-pt))
  (format #t "~1Tpartial-pt: ~f~%" (-> obj partial-pt))
  (label cfg-4)
  obj
  )

;; definition of type tracking-spline
(deftype tracking-spline (structure)
  ((point              tracking-point 32 :inline :offset-assert   0)
   (summed-len         float                     :offset-assert 1536)
   (free-point         int32                     :offset-assert 1540)
   (used-point         int32                     :offset-assert 1544)
   (partial-point      float                     :offset-assert 1548)
   (end-point          int32                     :offset-assert 1552)
   (next-to-last-point int32                     :offset-assert 1556)
   (max-move           float                     :offset-assert 1560)
   (sample-len         float                     :offset-assert 1564)
   (used-count         int32                     :offset-assert 1568)
   (old-position       vector         :inline    :offset-assert 1584)
   (debug-old-position vector         :inline    :offset-assert 1600)
   (debug-out-position vector         :inline    :offset-assert 1616)
   (debug-last-point   int32                     :offset-assert 1632)
   )
  :method-count-assert 24
  :size-assert         #x664
  :flag-assert         #x1800000664
  (:methods
    (tracking-spline-method-9 (_type_) none 9)
    (tracking-spline-method-10 (_type_ vector) none 10)
    (debug-point-info (_type_ int) none 11)
    (debug-all-points (_type_) none 12)
    (tracking-spline-method-13 (_type_ int) none 13)
    (tracking-spline-method-14 (_type_ tracking-spline-sampler) none 14)
    (tracking-spline-method-15 (_type_) none 15)
    (tracking-spline-method-16 (_type_ float) none 16)
    (tracking-spline-method-17 (_type_ vector float float symbol) int 17)
    (tracking-spline-method-18 (_type_ float vector tracking-spline-sampler) vector 18)
    (tracking-spline-method-19 (_type_ float vector tracking-spline-sampler) vector 19)
    (tracking-spline-method-20 (_type_ vector int) none 20)
    (tracking-spline-method-21 (_type_ vector float float float) vector 21)
    (tracking-spline-method-22 (_type_ float) symbol 22)
    (debug-draw-spline (_type_) none 23)
    )
  )

;; definition for method 3 of type tracking-spline
(defmethod inspect tracking-spline ((obj tracking-spline))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'tracking-spline)
  (format #t "~1Tpoint[32] @ #x~X~%" (-> obj point))
  (format #t "~1Tsummed-len: ~f~%" (-> obj summed-len))
  (format #t "~1Tfree-point: ~D~%" (-> obj free-point))
  (format #t "~1Tused-point: ~D~%" (-> obj used-point))
  (format #t "~1Tpartial-point: ~f~%" (-> obj partial-point))
  (format #t "~1Tend-point: ~D~%" (-> obj end-point))
  (format #t "~1Tnext-to-last-point: ~D~%" (-> obj next-to-last-point))
  (format #t "~1Tmax-move: ~f~%" (-> obj max-move))
  (format #t "~1Tsample-len: ~f~%" (-> obj sample-len))
  (format #t "~1Tused-count: ~D~%" (-> obj used-count))
  (format #t "~1Told-position: #<vector @ #x~X>~%" (-> obj old-position))
  (format #t "~1Tdebug-old-position: #<vector @ #x~X>~%" (-> obj debug-old-position))
  (format #t "~1Tdebug-out-position: #<vector @ #x~X>~%" (-> obj debug-out-position))
  (format #t "~1Tdebug-last-point: ~D~%" (-> obj debug-last-point))
  (label cfg-4)
  obj
  )

;; definition of type cam-float-seeker
(deftype cam-float-seeker (structure)
  ((target      float  :offset-assert   0)
   (value       float  :offset-assert   4)
   (vel         float  :offset-assert   8)
   (accel       float  :offset-assert  12)
   (max-vel     float  :offset-assert  16)
   (max-partial float  :offset-assert  20)
   )
  :pack-me
  :method-count-assert 13
  :size-assert         #x18
  :flag-assert         #xd00000018
  (:methods
    (init (_type_ float float float float) none 9)
    (copy-to (_type_ _type_) none 10)
    (update! (_type_ float) none 11)
    (jump-to-target! (_type_ float) float 12)
    )
  )

;; definition for method 3 of type cam-float-seeker
(defmethod inspect cam-float-seeker ((obj cam-float-seeker))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'cam-float-seeker)
  (format #t "~1Ttarget: ~f~%" (-> obj target))
  (format #t "~1Tvalue: ~f~%" (-> obj value))
  (format #t "~1Tvel: ~f~%" (-> obj vel))
  (format #t "~1Taccel: ~f~%" (-> obj accel))
  (format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
  (format #t "~1Tmax-partial: ~f~%" (-> obj max-partial))
  (label cfg-4)
  obj
  )

;; definition for method 9 of type cam-float-seeker
;; WARN: Return type mismatch int vs none.
(defmethod init cam-float-seeker ((obj cam-float-seeker) (arg0 float) (arg1 float) (arg2 float) (arg3 float))
  (set! (-> obj target) arg0)
  (set! (-> obj value) arg0)
  (set! (-> obj vel) 0.0)
  (set! (-> obj accel) arg1)
  (set! (-> obj max-vel) arg2)
  (set! (-> obj max-partial) arg3)
  0
  (none)
  )

;; definition for method 10 of type cam-float-seeker
;; WARN: Return type mismatch int vs none.
(defmethod copy-to cam-float-seeker ((obj cam-float-seeker) (arg0 cam-float-seeker))
  (set! (-> obj target) (-> arg0 target))
  (set! (-> obj value) (-> arg0 value))
  (set! (-> obj vel) (-> arg0 vel))
  (set! (-> obj accel) (-> arg0 accel))
  (set! (-> obj max-vel) (-> arg0 max-vel))
  (set! (-> obj max-partial) (-> arg0 max-partial))
  0
  (none)
  )

;; definition for method 11 of type cam-float-seeker
;; WARN: Return type mismatch int vs none.
(defmethod update! cam-float-seeker ((obj cam-float-seeker) (arg0 float))
  (with-pp
    0.0
    0.0
    (let* ((f1-2 (- (+ (-> obj target) arg0) (-> obj value)))
           (f0-5 (* (-> obj max-partial) (fabs f1-2)))
           )
      (let ((f1-3 (* f1-2 (* (-> obj accel) (-> pp clock time-adjust-ratio)))))
        (+! (-> obj vel) f1-3)
        )
      (let ((f1-6 (fabs (-> obj vel)))
            (f0-6 (fmin f0-5 (-> obj max-vel)))
            )
        (if (< f0-6 f1-6)
            (set! (-> obj vel) (* (-> obj vel) (/ f0-6 f1-6)))
            )
        )
      )
    (let ((f0-10 (* (-> obj vel) (-> pp clock time-adjust-ratio))))
      (+! (-> obj value) f0-10)
      )
    0
    (none)
    )
  )

;; definition for method 12 of type cam-float-seeker
(defmethod jump-to-target! cam-float-seeker ((obj cam-float-seeker) (arg0 float))
  (set! (-> obj value) (+ (-> obj target) arg0))
  (set! (-> obj vel) 0.0)
  0.0
  )

;; definition of type cam-vector-seeker
(deftype cam-vector-seeker (structure)
  ((target      vector :inline :offset-assert   0)
   (value       vector :inline :offset-assert  16)
   (vel         vector :inline :offset-assert  32)
   (accel       float          :offset-assert  48)
   (max-vel     float          :offset-assert  52)
   (max-partial float          :offset-assert  56)
   )
  :method-count-assert 11
  :size-assert         #x3c
  :flag-assert         #xb0000003c
  (:methods
    (init (_type_ vector float float float) none 9)
    (update! (_type_ vector) none 10)
    )
  )

;; definition for method 3 of type cam-vector-seeker
(defmethod inspect cam-vector-seeker ((obj cam-vector-seeker))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'cam-vector-seeker)
  (format #t "~1Ttarget: #<vector @ #x~X>~%" (-> obj target))
  (format #t "~1Tvalue: #<vector @ #x~X>~%" (-> obj value))
  (format #t "~1Tvel: #<vector @ #x~X>~%" (-> obj vel))
  (format #t "~1Taccel: ~f~%" (-> obj accel))
  (format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
  (format #t "~1Tmax-partial: ~f~%" (-> obj max-partial))
  (label cfg-4)
  obj
  )

;; definition for method 9 of type cam-vector-seeker
;; INFO: Used lq/sq
;; WARN: Return type mismatch int vs none.
(defmethod init cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector) (arg1 float) (arg2 float) (arg3 float))
  (cond
    (arg0
      (set! (-> obj target quad) (-> arg0 quad))
      (set! (-> obj value quad) (-> arg0 quad))
      )
    (else
      (vector-reset! (-> obj target))
      (vector-reset! (-> obj value))
      )
    )
  (vector-reset! (-> obj vel))
  (set! (-> obj accel) arg1)
  (set! (-> obj max-vel) arg2)
  (set! (-> obj max-partial) arg3)
  0
  (none)
  )

;; definition for method 10 of type cam-vector-seeker
;; WARN: Return type mismatch int vs none.
(defmethod update! cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector))
  (with-pp
    (let ((v1-0 (new 'stack-no-clear 'vector)))
      0.0
      (cond
        (arg0
          (vector+! v1-0 (-> obj target) arg0)
          (vector-! v1-0 v1-0 (-> obj value))
          )
        (else
          (vector-! v1-0 (-> obj target) (-> obj value))
          )
        )
      (let ((f0-2 (* (-> obj max-partial) (vector-length v1-0))))
        (vector-float*! v1-0 v1-0 (* (-> obj accel) (-> pp clock time-adjust-ratio)))
        (vector+! (-> obj vel) (-> obj vel) v1-0)
        (let ((f1-3 (vector-length (-> obj vel)))
              (f0-3 (fmin f0-2 (-> obj max-vel)))
              )
          (if (< f0-3 f1-3)
              (vector-float*! (-> obj vel) (-> obj vel) (/ f0-3 f1-3))
              )
          )
        )
      (vector-float*! v1-0 (-> obj vel) (-> pp clock time-adjust-ratio))
      (vector+! (-> obj value) (-> obj value) v1-0)
      )
    0
    (none)
    )
  )

;; definition of type cam-rotation-tracker
(deftype cam-rotation-tracker (structure)
  ((inv-mat                 matrix           :inline :offset-assert   0)
   (no-follow               basic                    :offset-assert  64)
   (follow-pt               vector           :inline :offset-assert  80)
   (follow-off              vector           :inline :offset-assert  96)
   (follow-blend            float                    :offset-assert 112)
   (tilt-adjust             cam-float-seeker :inline :offset-assert 116)
   (point-of-interest-blend cam-float-seeker :inline :offset-assert 140)
   (underwater-blend        cam-float-seeker :inline :offset-assert 164)
   (looking-at              vector           :inline :offset-assert 192)
   (looking-interesting     vector           :inline :offset-assert 208)
   (old-cam-trans           vector           :inline :offset-assert 224)
   (follow-height-extra     cam-float-seeker :inline :offset-assert 240)
   )
  :method-count-assert 9
  :size-assert         #x108
  :flag-assert         #x900000108
  )

;; definition for method 3 of type cam-rotation-tracker
(defmethod inspect cam-rotation-tracker ((obj cam-rotation-tracker))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'cam-rotation-tracker)
  (format #t "~1Tinv-mat: ~`matrix`P~%" (-> obj inv-mat))
  (format #t "~1Tno-follow: ~A~%" (-> obj no-follow))
  (format #t "~1Tfollow-pt: ~`vector`P~%" (-> obj follow-pt))
  (format #t "~1Tfollow-off: ~`vector`P~%" (-> obj follow-off))
  (format #t "~1Tfollow-blend: ~f~%" (-> obj follow-blend))
  (format #t "~1Ttilt-adjust: #<cam-float-seeker @ #x~X>~%" (-> obj tilt-adjust))
  (format #t "~1Tpoint-of-interest-blend: #<cam-float-seeker @ #x~X>~%" (-> obj point-of-interest-blend))
  (format #t "~1Tunderwater-blend: #<cam-float-seeker @ #x~X>~%" (-> obj underwater-blend))
  (format #t "~1Tlooking-at: ~`vector`P~%" (-> obj looking-at))
  (format #t "~1Tlooking-interesting: ~`vector`P~%" (-> obj looking-interesting))
  (format #t "~1Told-cam-trans: ~`vector`P~%" (-> obj old-cam-trans))
  (format #t "~1Tfollow-height-extra: #<cam-float-seeker @ #x~X>~%" (-> obj follow-height-extra))
  (label cfg-4)
  obj
  )

;; definition of type camera-combiner
(deftype camera-combiner (process)
  ((trans             vector               :inline :offset-assert 128)
   (inv-camera-rot    matrix               :inline :offset-assert 144)
   (fov               float                        :offset-assert 208)
   (interp-val        float                        :offset-assert 212)
   (interp-step       float                        :offset-assert 216)
   (dist-from-src     float                        :offset-assert 220)
   (dist-from-dest    float                        :offset-assert 224)
   (flip-control-axis vector               :inline :offset-assert 240)
   (velocity          vector               :inline :offset-assert 256)
   (tracking-status   uint64                       :offset-assert 272)
   (tracking-options  int32                        :offset-assert 280)
   (tracking          cam-rotation-tracker :inline :offset-assert 288)
   (fast-rot          basic                        :offset-assert 552)
   )
  :heap-base #x1b0
  :method-count-assert 14
  :size-assert         #x22c
  :flag-assert         #xe01b0022c
  )

;; definition for method 3 of type camera-combiner
(defmethod inspect camera-combiner ((obj camera-combiner))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~2Ttrans: ~`vector`P~%" (-> obj trans))
  (format #t "~2Tinv-camera-rot: ~`matrix`P~%" (-> obj inv-camera-rot))
  (format #t "~2Tfov: ~f~%" (-> obj fov))
  (format #t "~2Tinterp-val: ~f~%" (-> obj interp-val))
  (format #t "~2Tinterp-step: ~f~%" (-> obj interp-step))
  (format #t "~2Tdist-from-src: ~f~%" (-> obj dist-from-src))
  (format #t "~2Tdist-from-dest: ~f~%" (-> obj dist-from-dest))
  (format #t "~2Tflip-control-axis: #<vector @ #x~X>~%" (-> obj flip-control-axis))
  (format #t "~2Tvelocity: #<vector @ #x~X>~%" (-> obj velocity))
  (format #t "~2Ttracking-status: ~D~%" (-> obj tracking-status))
  (format #t "~2Ttracking-options: ~D~%" (-> obj tracking-options))
  (format #t "~2Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
  (format #t "~2Tfast-rot: ~A~%" (-> obj fast-rot))
  (label cfg-4)
  obj
  )

;; definition of type camera-slave
(deftype camera-slave (process)
  ((trans                         vector               :inline :offset-assert 128)
   (fov                           float                        :offset-assert 144)
   (fov0                          float                        :offset-assert 148)
   (fov1                          float                        :offset-assert 152)
   (fov-index                     cam-index            :inline :offset-assert 160)
   (tracking                      cam-rotation-tracker :inline :offset-assert 208)
   (view-off-param                float                        :offset-assert 472)
   (view-off                      vector               :inline :offset-assert 480)
   (joystick-saved-view-off       vector               :inline :offset-assert 496)
   (min-z-override                float                        :offset-assert 512)
   (view-flat                     vector               :inline :offset-assert 528)
   (string-vel-dir                uint32                       :offset-assert 544)
   (string-trans                  vector               :inline :offset-assert 560)
   (position-spline               tracking-spline      :inline :offset-assert 576)
   (pivot-pt                      vector               :inline :offset-assert 2224)
   (pivot-rad                     float                        :offset-assert 2240)
   (circular-follow               vector               :inline :offset-assert 2256)
   (max-angle-offset              float                        :offset-assert 2272)
   (max-angle-curr                float                        :offset-assert 2276)
   (options                       uint32                       :offset-assert 2280)
   (cam-entity                    entity                       :offset-assert 2284)
   (butt-timer                    uint64                       :offset-assert 2288)
   (butt-seek                     basic                        :offset-assert 2296)
   (butt-vector                   vector               :inline :offset-assert 2304)
   (velocity                      vector               :inline :offset-assert 2320)
   (desired-pos                   vector               :inline :offset-assert 2336)
   (time-dist-too-far             uint32                       :offset-assert 2352)
   (los-state                     slave-los-state              :offset-assert 2356)
   (good-point                    vector               :inline :offset-assert 2368)
   (los-tgt-spline-pt             int32                        :offset-assert 2384)
   (los-tgt-spline-pt-incarnation int32                        :offset-assert 2388)
   (los-last-pos                  vector               :inline :offset-assert 2400)
   (intro-curve                   curve                :inline :offset-assert 2416)
   (intro-offset                  vector               :inline :offset-assert 2448)
   (intro-t                       float                        :offset-assert 2464)
   (intro-t-step                  float                        :offset-assert 2468)
   (outro-exit-value              float                        :offset-assert 2472)
   (spline-exists                 basic                        :offset-assert 2476)
   (spline-curve                  curve                :inline :offset-assert 2480)
   (spline-offset                 vector               :inline :offset-assert 2512)
   (index                         cam-index            :inline :offset-assert 2528)
   (saved-pt                      vector               :inline :offset-assert 2576)
   (spline-tt                     float                        :offset-assert 2592)
   (spline-follow-dist            float                        :offset-assert 2596)
   (enter-has-run                 symbol                       :offset-assert 2600)
   (blend-from-type               uint64                       :offset-assert 2608)
   (blend-to-type                 camera-blend-to-type         :offset-assert 2616)
   (have-phony-joystick           basic                        :offset-assert 2624)
   (phony-joystick-x              float                        :offset-assert 2628)
   (phony-joystick-y              float                        :offset-assert 2632)
   (string-min-val                vector               :inline :offset-assert 2640)
   (string-max-val                vector               :inline :offset-assert 2656)
   (string-val-locked             basic                        :offset-assert 2672)
   (relative-position             vector               :inline :offset-assert 2688)
   (string-relative               basic                        :offset-assert 2704)
   )
  :heap-base #xa20
  :method-count-assert 14
  :size-assert         #xa94
  :flag-assert         #xe0a200a94
  (:states
    cam-bike
    cam-circular
    cam-decel
    cam-endlessfall
    cam-eye
    cam-fixed
    cam-fixed-read-entity
    cam-free-floating
    cam-lookat
    cam-point-watch
    cam-pov
    cam-pov-track
    cam-pov180
    cam-really-fixed
    cam-robotboss
    cam-spline
    cam-standoff
    cam-standoff-read-entity
    cam-stick
    cam-string
    )
  )

;; definition for method 3 of type camera-slave
(defmethod inspect camera-slave ((obj camera-slave))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~2Ttrans: ~`vector`P~%" (-> obj trans))
  (format #t "~2Tfov: ~f~%" (-> obj fov))
  (format #t "~2Tfov0: ~f~%" (-> obj fov0))
  (format #t "~2Tfov1: ~f~%" (-> obj fov1))
  (format #t "~2Tfov-index: #<cam-index @ #x~X>~%" (-> obj fov-index))
  (format #t "~2Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
  (format #t "~2Tview-off-param: ~f~%" (-> obj view-off-param))
  (format #t "~2Tview-off: ~`vector`P~%" (-> obj view-off))
  (format #t "~2Tjoystick-saved-view-off: ~`vector`P~%" (-> obj joystick-saved-view-off))
  (format #t "~2Tmin-z-override: ~f~%" (-> obj min-z-override))
  (format #t "~2Tview-flat: ~`vector`P~%" (-> obj view-flat))
  (format #t "~2Tstring-vel-dir: ~D~%" (-> obj string-vel-dir))
  (format #t "~2Tstring-trans: ~`vector`P~%" (-> obj string-trans))
  (format #t "~2Tposition-spline: #<tracking-spline @ #x~X>~%" (-> obj position-spline))
  (format #t "~2Tpivot-pt: ~`vector`P~%" (-> obj pivot-pt))
  (format #t "~2Tpivot-rad: ~f~%" (-> obj pivot-rad))
  (format #t "~2Tcircular-follow: #<vector @ #x~X>~%" (-> obj circular-follow))
  (format #t "~2Tmax-angle-offset: ~f~%" (-> obj max-angle-offset))
  (format #t "~2Tmax-angle-curr: ~f~%" (-> obj max-angle-curr))
  (format #t "~2Toptions: ~D~%" (-> obj options))
  (format #t "~2Tcam-entity: ~A~%" (-> obj cam-entity))
  (format #t "~2Tbutt-timer: ~D~%" (-> obj butt-timer))
  (format #t "~2Tbutt-seek: ~A~%" (-> obj butt-seek))
  (format #t "~2Tbutt-vector: ~`vector`P~%" (-> obj butt-vector))
  (format #t "~2Tvelocity: ~`vector`P~%" (-> obj velocity))
  (format #t "~2Tdesired-pos: ~`vector`P~%" (-> obj desired-pos))
  (format #t "~2Ttime-dist-too-far: ~D~%" (-> obj time-dist-too-far))
  (format #t "~2Tlos-state: ~D~%" (-> obj los-state))
  (format #t "~2Tgood-point: ~`vector`P~%" (-> obj good-point))
  (format #t "~2Tlos-tgt-spline-pt: ~D~%" (-> obj los-tgt-spline-pt))
  (format #t "~2Tlos-tgt-spline-pt-incarnation: ~D~%" (-> obj los-tgt-spline-pt-incarnation))
  (format #t "~2Tlos-last-pos: ~`vector`P~%" (-> obj los-last-pos))
  (format #t "~2Tintro-curve: #<curve @ #x~X>~%" (-> obj intro-curve))
  (format #t "~2Tintro-offset: #<vector @ #x~X>~%" (-> obj intro-offset))
  (format #t "~2Tintro-t: ~f~%" (-> obj intro-t))
  (format #t "~2Tintro-t-step: ~f~%" (-> obj intro-t-step))
  (format #t "~2Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
  (format #t "~2Tspline-exists: ~A~%" (-> obj spline-exists))
  (format #t "~2Tspline-curve: #<curve @ #x~X>~%" (-> obj spline-curve))
  (format #t "~2Tspline-offset: #<vector @ #x~X>~%" (-> obj spline-offset))
  (format #t "~2Tindex: #<cam-index @ #x~X>~%" (-> obj index))
  (format #t "~2Tsaved-pt: #<vector @ #x~X>~%" (-> obj saved-pt))
  (format #t "~2Tspline-tt: ~f~%" (-> obj spline-tt))
  (format #t "~2Tspline-follow-dist: ~f~%" (-> obj spline-follow-dist))
  (format #t "~2Tenter-has-run: ~A~%" (-> obj enter-has-run))
  (format #t "~2Tblend-from-type: ~D~%" (-> obj blend-from-type))
  (format #t "~2Tblend-to-type: ~D~%" (-> obj blend-to-type))
  (format #t "~2Thave-phony-joystick: ~A~%" (-> obj have-phony-joystick))
  (format #t "~2Tphony-joystick-x: ~f~%" (-> obj phony-joystick-x))
  (format #t "~2Tphony-joystick-y: ~f~%" (-> obj phony-joystick-y))
  (format #t "~2Tstring-min-val: #<vector @ #x~X>~%" (-> obj string-min-val))
  (format #t "~2Tstring-max-val: #<vector @ #x~X>~%" (-> obj string-max-val))
  (format #t "~2Tstring-val-locked: ~A~%" (-> obj string-val-locked))
  (format #t "~2Trelative-position: #<vector @ #x~X>~%" (-> obj relative-position))
  (format #t "~2Tstring-relative: ~A~%" (-> obj string-relative))
  (label cfg-4)
  obj
  )

;; definition of type camera-master
(deftype camera-master (process)
  ((master-options      uint32                           :offset-assert 128)
   (settings            cam-setting-data                 :offset-assert 132)
   (slave               (pointer camera-slave)           :offset-assert 136)
   (decel               (pointer camera-slave)           :offset-assert 140)
   (slave-options       uint32                           :offset-assert 144)
   (view-off-param-save float                            :offset-assert 148)
   (changer             uint32                           :offset-assert 152)
   (string-min          cam-vector-seeker        :inline :offset-assert 160)
   (string-max          cam-vector-seeker        :inline :offset-assert 224)
   (string-push-z       float                            :offset-assert 284)
   (local-down          vector                   :inline :offset-assert 288)
   (focus               focus                    :inline :offset-assert 304)
   (being-attacked      symbol                           :offset-assert 316)
   (attack-start        time-frame                       :offset-assert 320)
   (on-ground           symbol                           :offset-assert 328)
   (under-water         int32                            :offset-assert 332)
   (on-pole             symbol                           :offset-assert 336)
   (tgt-rot-mat         matrix                   :inline :offset-assert 352)
   (tgt-face-mat        matrix                   :inline :offset-assert 416)
   (tpos-old            vector                   :inline :offset-assert 480)
   (tpos-curr           vector                   :inline :offset-assert 496)
   (tpos-old-adj        vector                   :inline :offset-assert 512)
   (tpos-curr-adj       vector                   :inline :offset-assert 528)
   (tpos-tgt            vector                   :inline :offset-assert 544)
   (upspeed             float                            :offset-assert 560)
   (pitch-off           vector                   :inline :offset-assert 576)
   (target-spline       tracking-spline          :inline :offset-assert 592)
   (ease-from           vector                   :inline :offset-assert 2240)
   (ease-t              float                            :offset-assert 2256)
   (ease-step           float                            :offset-assert 2260)
   (ease-to             vector                   :inline :offset-assert 2272)
   (outro-curve         curve                    :inline :offset-assert 2288)
   (outro-t             float                            :offset-assert 2308)
   (outro-t-step        float                            :offset-assert 2312)
   (outro-exit-value    float                            :offset-assert 2316)
   (water-drip-time     time-frame                       :offset-assert 2320)
   (water-drip          sparticle-launch-control         :offset-assert 2328)
   (water-drip-mult     float                            :offset-assert 2332)
   (water-drip-speed    float                            :offset-assert 2336)
   )
  :heap-base #x8b0
  :method-count-assert 17
  :size-assert         #x924
  :flag-assert         #x1108b00924
  (:methods
    (camera-master-method-14 (_type_ vector) vector 14)
    (camera-master-method-15 (_type_ vector) vector 15)
    (camera-master-method-16 (_type_ symbol) int 16)
    )
  )

;; definition for method 3 of type camera-master
(defmethod inspect camera-master ((obj camera-master))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~2Tmaster-options: ~D~%" (-> obj master-options))
  (format #t "~2Tsettings: #<cam-setting-data @ #x~X>~%" (-> obj settings))
  (format #t "~2Tslave: #x~X~%" (-> obj slave))
  (format #t "~2Tdecel: #x~X~%" (-> obj decel))
  (format #t "~2Tslave-options: ~D~%" (-> obj slave-options))
  (format #t "~2Tview-off-param-save: ~f~%" (-> obj view-off-param-save))
  (format #t "~2Tchanger: #x~X~%" (-> obj changer))
  (format #t "~2Tstring-min: #<cam-vector-seeker @ #x~X>~%" (-> obj string-min))
  (format #t "~2Tstring-max: #<cam-vector-seeker @ #x~X>~%" (-> obj string-max))
  (format #t "~2Tstring-push-z: ~f~%" (-> obj string-push-z))
  (format #t "~2Tlocal-down: ~`vector`P~%" (-> obj local-down))
  (format #t "~2Tfocus: #<focus @ #x~X>~%" (-> obj focus))
  (format #t "~2Tbeing-attacked: ~A~%" (-> obj being-attacked))
  (format #t "~2Tattack-start: ~D~%" (-> obj attack-start))
  (format #t "~2Ton-ground: ~A~%" (-> obj on-ground))
  (format #t "~2Tunder-water: ~D~%" (-> obj under-water))
  (format #t "~2Ton-pole: ~A~%" (-> obj on-pole))
  (format #t "~2Ttgt-rot-mat: ~`matrix`P~%" (-> obj tgt-rot-mat))
  (format #t "~2Ttgt-face-mat: ~`matrix`P~%" (-> obj tgt-face-mat))
  (format #t "~2Ttpos-old: ~`vector`P~%" (-> obj tpos-old))
  (format #t "~2Ttpos-curr: ~`vector`P~%" (-> obj tpos-curr))
  (format #t "~2Ttpos-old-adj: ~`vector`P~%" (-> obj tpos-old-adj))
  (format #t "~2Ttpos-curr-adj: ~`vector`P~%" (-> obj tpos-curr-adj))
  (format #t "~2Ttpos-tgt: ~`vector`P~%" (-> obj tpos-tgt))
  (format #t "~2Tupspeed: ~f~%" (-> obj upspeed))
  (format #t "~2Tpitch-off: ~`vector`P~%" (-> obj pitch-off))
  (format #t "~2Ttarget-spline: #<tracking-spline @ #x~X>~%" (-> obj target-spline))
  (format #t "~2Tease-from: #<vector @ #x~X>~%" (-> obj ease-from))
  (format #t "~2Tease-t: ~f~%" (-> obj ease-t))
  (format #t "~2Tease-step: ~f~%" (-> obj ease-step))
  (format #t "~2Tease-to: #<vector @ #x~X>~%" (-> obj ease-to))
  (format #t "~2Toutro-curve: #<curve @ #x~X>~%" (-> obj outro-curve))
  (format #t "~2Toutro-t: ~f~%" (-> obj outro-t))
  (format #t "~2Toutro-t-step: ~f~%" (-> obj outro-t-step))
  (format #t "~2Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
  (format #t "~2Twater-drip-time: ~D~%" (-> obj water-drip-time))
  (format #t "~2Twater-drip: ~A~%" (-> obj water-drip))
  (format #t "~2Twater-drip-mult: ~f~%" (-> obj water-drip-mult))
  (format #t "~2Twater-drip-speed: ~f~%" (-> obj water-drip-speed))
  (label cfg-4)
  obj
  )

;; failed to figure out what this is:
0