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

;; definition of type camera-bank
(deftype camera-bank (basic)
  ((collide-move-rad        float       :offset-assert   4)
   (joypad                  uint32      :offset-assert   8)
   (min-detectable-velocity float       :offset-assert  12)
   (attack-timeout          time-frame  :offset-assert  16)
   (default-string-max-y    meters      :offset-assert  24)
   (default-string-min-y    meters      :offset-assert  28)
   (default-string-max-z    meters      :offset-assert  32)
   (default-string-min-z    meters      :offset-assert  36)
   (default-string-push-z   meters      :offset-assert  40)
   (default-tilt-adjust     degrees     :offset-assert  44)
   )
  :method-count-assert 9
  :size-assert         #x30
  :flag-assert         #x900000030
  )

;; definition for method 3 of type camera-bank
(defmethod inspect camera-bank ((obj camera-bank))
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~Tcollide-move-rad: ~f~%" (-> obj collide-move-rad))
  (format #t "~Tjoypad: ~D~%" (-> obj joypad))
  (format #t "~Tmin-detectable-velocity: ~f~%" (-> obj min-detectable-velocity))
  (format #t "~Tattack-timeout: ~D~%" (-> obj attack-timeout))
  (format #t "~Tdefault-string-max-y: (meters ~m)~%" (-> obj default-string-max-y))
  (format #t "~Tdefault-string-min-y: (meters ~m)~%" (-> obj default-string-min-y))
  (format #t "~Tdefault-string-max-z: (meters ~m)~%" (-> obj default-string-max-z))
  (format #t "~Tdefault-string-min-z: (meters ~m)~%" (-> obj default-string-min-z))
  (format #t "~Tdefault-string-push-z: (meters ~m)~%" (-> obj default-string-push-z))
  (format #t "~Tdefault-tilt-adjust: (deg ~r)~%" (-> obj default-tilt-adjust))
  obj
  )

;; definition for symbol *CAMERA-bank*, type camera-bank
(define *CAMERA-bank* (new 'static 'camera-bank
                        :collide-move-rad 1638.4
                        :min-detectable-velocity 40.96
                        :attack-timeout (seconds 0.25)
                        :default-string-max-y (meters 3)
                        :default-string-min-y (meters 1)
                        :default-string-max-z (meters 12.5)
                        :default-string-min-z (meters 5)
                        :default-string-push-z (meters 10)
                        :default-tilt-adjust (degrees -6.5000005)
                        )
        )

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

;; definition for method 3 of type cam-index
(defmethod inspect cam-index ((obj cam-index))
  (format #t "[~8x] ~A~%" obj 'cam-index)
  (format #t "~Tflags: ~D~%" (-> obj flags))
  (format #t "~Tvec[2] @ #x~X~%" (-> obj vec))
  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))
  (format #t "[~8x] ~A~%" obj 'tracking-point)
  (format #t "~Tposition: #<vector @ #x~X>~%" (-> obj position))
  (format #t "~Tdirection: #<vector @ #x~X>~%" (-> obj direction))
  (format #t "~Ttp-length: ~f~%" (-> obj tp-length))
  (format #t "~Tnext: ~D~%" (-> obj next))
  (format #t "~Tincarnation: ~D~%" (-> obj incarnation))
  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))
  (format #t "[~8x] ~A~%" obj 'tracking-spline-sampler)
  (format #t "~Tcur-pt: ~D~%" (-> obj cur-pt))
  (format #t "~Tpartial-pt: ~f~%" (-> obj partial-pt))
  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
    (TODO-RENAME-9 (_type_) none 9)
    (TODO-RENAME-10 (_type_ vector) none 10)
    (print-nth-point (_type_ int) none 11)
    (TODO-RENAME-12 (_type_) none 12)
    (TODO-RENAME-13 (_type_ int) none 13)
    (TODO-RENAME-14 (_type_ tracking-spline-sampler) none 14)
    (TODO-RENAME-15 (_type_) none 15)
    (TODO-RENAME-16 (_type_ float) none 16)
    (TODO-RENAME-17 (_type_ vector float float symbol) int 17)
    (TODO-RENAME-18 (_type_ float vector tracking-spline-sampler) vector 18)
    (TODO-RENAME-19 (_type_ float vector tracking-spline-sampler) vector 19)
    (TODO-RENAME-20 (_type_ vector int) none 20)
    (TODO-RENAME-21 (_type_ vector float float) vector 21)
    (TODO-RENAME-22 (_type_ float) none 22)
    (TODO-RENAME-23 (_type_) none 23)
    )
  )

;; definition for method 3 of type tracking-spline
(defmethod inspect tracking-spline ((obj tracking-spline))
  (format #t "[~8x] ~A~%" obj 'tracking-spline)
  (format #t "~Tpoint[32] @ #x~X~%" (-> obj point))
  (format #t "~Tsummed-len: ~f~%" (-> obj summed-len))
  (format #t "~Tfree-point: ~D~%" (-> obj free-point))
  (format #t "~Tused-point: ~D~%" (-> obj used-point))
  (format #t "~Tpartial-point: ~f~%" (-> obj partial-point))
  (format #t "~Tend-point: ~D~%" (-> obj end-point))
  (format #t "~Tnext-to-last-point: ~D~%" (-> obj next-to-last-point))
  (format #t "~Tmax-move: ~f~%" (-> obj max-move))
  (format #t "~Tsample-len: ~f~%" (-> obj sample-len))
  (format #t "~Tused-count: ~D~%" (-> obj used-count))
  (format #t "~Told-position: #<vector @ #x~X>~%" (-> obj old-position))
  (format #t "~Tdebug-old-position: #<vector @ #x~X>~%" (-> obj debug-old-position))
  (format #t "~Tdebug-out-position: #<vector @ #x~X>~%" (-> obj debug-out-position))
  (format #t "~Tdebug-last-point: ~D~%" (-> obj debug-last-point))
  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-cam-float-seeker (_type_ float float float float) none 9)
    (copy-cam-float-seeker (_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))
  (format #t "[~8x] ~A~%" obj 'cam-float-seeker)
  (format #t "~Ttarget: ~f~%" (-> obj target))
  (format #t "~Tvalue: ~f~%" (-> obj value))
  (format #t "~Tvel: ~f~%" (-> obj vel))
  (format #t "~Taccel: ~f~%" (-> obj accel))
  (format #t "~Tmax-vel: ~f~%" (-> obj max-vel))
  (format #t "~Tmax-partial: ~f~%" (-> obj max-partial))
  obj
  )

;; definition for method 9 of type cam-float-seeker
;; INFO: Return type mismatch int vs none.
(defmethod init-cam-float-seeker 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
;; INFO: Return type mismatch int vs none.
(defmethod copy-cam-float-seeker 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
;; INFO: Return type mismatch int vs none.
(defmethod update! cam-float-seeker ((obj cam-float-seeker) (offset float))
  0.0
  0.0
  (let* ((pos-error (- (+ (-> obj target) offset) (-> obj value)))
         (partial-velocity-limit (* (-> obj max-partial) (fabs pos-error)))
         )
    (let ((daccel (* pos-error (* (-> obj accel) (-> *display* time-adjust-ratio)))))
      (+! (-> obj vel) daccel)
      )
    (let ((abs-vel (fabs (-> obj vel)))
          (abs-vel-limit (fmin partial-velocity-limit (-> obj max-vel)))
          )
      (if (< abs-vel-limit abs-vel)
          (set! (-> obj vel) (* (-> obj vel) (/ abs-vel-limit abs-vel)))
          )
      )
    )
  (let ((dpos (* (-> obj vel) (-> *display* time-adjust-ratio))))
    (+! (-> obj value) dpos)
    )
  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))
  (let ((f0-2 0.0))
    (set! (-> obj vel) f0-2)
    f0-2
    )
  )

;; 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))
  (format #t "[~8x] ~A~%" obj 'cam-vector-seeker)
  (format #t "~Ttarget: #<vector @ #x~X>~%" (-> obj target))
  (format #t "~Tvalue: #<vector @ #x~X>~%" (-> obj value))
  (format #t "~Tvel: #<vector @ #x~X>~%" (-> obj vel))
  (format #t "~Taccel: ~f~%" (-> obj accel))
  (format #t "~Tmax-vel: ~f~%" (-> obj max-vel))
  (format #t "~Tmax-partial: ~f~%" (-> obj max-partial))
  obj
  )

;; definition for method 9 of type cam-vector-seeker
;; INFO: Return type mismatch int vs none.
;; Used lq/sq
(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
;; INFO: Return type mismatch int vs none.
(defmethod update! cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector))
  (let ((gp-0 (new 'stack-no-clear 'vector)))
    0.0
    (cond
      (arg0
        (vector+! gp-0 (-> obj target) arg0)
        (vector-! gp-0 gp-0 (-> obj value))
        )
      (else
        (vector-! gp-0 (-> obj target) (-> obj value))
        )
      )
    (let ((f30-1 (* (-> obj max-partial) (vector-length gp-0))))
      (vector-float*! gp-0 gp-0 (* (-> obj accel) (-> *display* time-adjust-ratio)))
      (vector+! (-> obj vel) (-> obj vel) gp-0)
      (let ((f0-4 (vector-length (-> obj vel)))
            (f1-2 (fmin f30-1 (-> obj max-vel)))
            )
        (if (< f1-2 f0-4)
            (vector-float*! (-> obj vel) (-> obj vel) (/ f1-2 f0-4))
            )
        )
      )
    (vector-float*! gp-0 (-> obj vel) (-> *display* time-adjust-ratio))
    (vector+! (-> obj value) (-> obj value) gp-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)
   (use-point-of-interest   basic                    :offset-assert 140)
   (point-of-interest       vector           :inline :offset-assert 144)
   (point-of-interest-blend cam-float-seeker :inline :offset-assert 160)
   (underwater-blend        cam-float-seeker :inline :offset-assert 184)
   )
  :method-count-assert 9
  :size-assert         #xd0
  :flag-assert         #x9000000d0
  )

;; definition for method 3 of type cam-rotation-tracker
(defmethod inspect cam-rotation-tracker ((obj cam-rotation-tracker))
  (format #t "[~8x] ~A~%" obj 'cam-rotation-tracker)
  (format #t "~Tinv-mat: ~`matrix`P~%" (-> obj inv-mat))
  (format #t "~Tno-follow: ~A~%" (-> obj no-follow))
  (format #t "~Tfollow-pt: ~`vector`P~%" (-> obj follow-pt))
  (format #t "~Tfollow-off: ~`vector`P~%" (-> obj follow-off))
  (format #t "~Tfollow-blend: ~f~%" (-> obj follow-blend))
  (format #t "~Ttilt-adjust: #<cam-float-seeker @ #x~X>~%" (-> obj tilt-adjust))
  (format #t "~Tuse-point-of-interest: ~A~%" (-> obj use-point-of-interest))
  (format #t "~Tpoint-of-interest: ~`vector`P~%" (-> obj point-of-interest))
  (format #t "~Tpoint-of-interest-blend: #<cam-float-seeker @ #x~X>~%" (-> obj point-of-interest-blend))
  (format #t "~Tunderwater-blend: #<cam-float-seeker @ #x~X>~%" (-> obj underwater-blend))
  obj
  )

;; definition of type camera-combiner
(deftype camera-combiner (process)
  ((trans             vector               :inline :offset-assert 112)
   (inv-camera-rot    matrix               :inline :offset-assert 128)
   (fov               float                        :offset-assert 192)
   (interp-val        float                        :offset-assert 196)
   (interp-step       float                        :offset-assert 200)
   (dist-from-src     float                        :offset-assert 204)
   (dist-from-dest    float                        :offset-assert 208)
   (flip-control-axis vector               :inline :offset-assert 224)
   (velocity          vector               :inline :offset-assert 240)
   (tracking-status   uint64                       :offset-assert 256)
   (tracking-options  int32                        :offset-assert 264)
   (tracking          cam-rotation-tracker :inline :offset-assert 272)
   )
  :heap-base #x170
  :method-count-assert 14
  :size-assert         #x1e0
  :flag-assert         #xe017001e0
  (:states
    cam-combiner-active
    )
  )

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

;; definition of type camera-slave
(deftype camera-slave (process)
  ((trans                         vector                     :inline :offset-assert 112)
   (fov                           float                              :offset-assert 128)
   (fov0                          float                              :offset-assert 132)
   (fov1                          float                              :offset-assert 136)
   (fov-index                     cam-index                  :inline :offset-assert 144)
   (tracking                      cam-rotation-tracker       :inline :offset-assert 192)
   (view-off-param                float                              :offset-assert 400)
   (unknown-symbol                symbol                             :offset        412)
   (view-off                      vector                     :inline :offset-assert 416)
   (min-z-override                float                              :offset-assert 432)
   (view-flat                     vector                     :inline :offset-assert 448)
   (string-vel-dir                uint32                             :offset-assert 464)
   (string-trans                  vector                     :inline :offset-assert 480)
   (position-spline               tracking-spline            :inline :offset-assert 496)
   (pivot-pt                      vector                     :inline :offset-assert 2144)
   (pivot-rad                     float                              :offset-assert 2160)
   (circular-follow               vector                     :inline :offset-assert 2176)
   (max-angle-offset              float                              :offset-assert 2192)
   (max-angle-curr                float                              :offset-assert 2196)
   (options                       uint32                             :offset-assert 2200)
   (cam-entity                    entity                             :offset-assert 2204)
   (velocity                      vector                     :inline :offset-assert 2208)
   (desired-pos                   vector                     :inline :offset-assert 2224)
   (time-dist-too-far             uint32                             :offset-assert 2240)
   (los-state                     slave-los-state                    :offset-assert 2244)
   (good-point                    vector                     :inline :offset-assert 2256)
   (los-tgt-spline-pt             int32                              :offset-assert 2272)
   (los-tgt-spline-pt-incarnation int32                              :offset-assert 2276)
   (los-last-pos                  vector                     :inline :offset-assert 2288)
   (intro-curve                   curve                      :inline :offset-assert 2304)
   (intro-offset                  vector                     :inline :offset-assert 2336)
   (intro-t                       float                              :offset-assert 2352)
   (intro-t-step                  float                              :offset-assert 2356)
   (outro-exit-value              float                              :offset-assert 2360)
   (spline-exists                 basic                              :offset-assert 2364)
   (spline-curve                  curve                      :inline :offset-assert 2368)
   (spline-offset                 vector                     :inline :offset-assert 2400)
   (index                         cam-index                  :inline :offset-assert 2416)
   (saved-pt                      vector                     :inline :offset-assert 2464)
   (spline-tt                     float                              :offset-assert 2480)
   (spline-follow-dist            float                              :offset-assert 2484)
   (change-event-from             (pointer process-drawable)         :offset-assert 2488)
   (enter-has-run                 symbol                             :offset-assert 2492)
   (blend-from-type               uint64                             :offset-assert 2496)
   (blend-to-type                 uint64                             :offset-assert 2504)
   (have-phony-joystick           basic                              :offset-assert 2512)
   (phony-joystick-x              float                              :offset-assert 2516)
   (phony-joystick-y              float                              :offset-assert 2520)
   (string-min-val                vector                     :inline :offset-assert 2528)
   (string-max-val                vector                     :inline :offset-assert 2544)
   (string-val-locked             basic                              :offset-assert 2560)
   )
  :heap-base #x9a0
  :method-count-assert 14
  :size-assert         #xa04
  :flag-assert         #xe09a00a04
  (:states
    *camera-base-mode*
    cam-bike
    cam-billy
    cam-circular
    cam-decel
    cam-endlessfall
    cam-eye
    cam-fixed
    cam-fixed-read-entity
    cam-free-floating
    cam-launcher-longfall
    cam-launcher-shortfall
    cam-lookat
    cam-mistycannon
    cam-orbit
    cam-periscope
    cam-point-watch
    cam-pov
    cam-pov-track
    cam-pov180
    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))
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Ttrans: ~`vector`P~%" (-> obj trans))
  (format #t "~T~Tfov: ~f~%" (-> obj fov))
  (format #t "~T~Tfov0: ~f~%" (-> obj fov0))
  (format #t "~T~Tfov1: ~f~%" (-> obj fov1))
  (format #t "~T~Tfov-index: #<cam-index @ #x~X>~%" (-> obj fov-index))
  (format #t "~T~Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
  (format #t "~T~Tview-off-param: ~f~%" (-> obj view-off-param))
  (format #t "~T~Tview-off: ~`vector`P~%" (-> obj view-off))
  (format #t "~T~Tmin-z-override: ~f~%" (-> obj min-z-override))
  (format #t "~T~Tview-flat: ~`vector`P~%" (-> obj view-flat))
  (format #t "~T~Tstring-vel-dir: ~D~%" (-> obj string-vel-dir))
  (format #t "~T~Tstring-trans: ~`vector`P~%" (-> obj string-trans))
  (format #t "~T~Tposition-spline: #<tracking-spline @ #x~X>~%" (-> obj position-spline))
  (format #t "~T~Tpivot-pt: ~`vector`P~%" (-> obj pivot-pt))
  (format #t "~T~Tpivot-rad: ~f~%" (-> obj pivot-rad))
  (format #t "~T~Tcircular-follow: #<vector @ #x~X>~%" (-> obj circular-follow))
  (format #t "~T~Tmax-angle-offset: ~f~%" (-> obj max-angle-offset))
  (format #t "~T~Tmax-angle-curr: ~f~%" (-> obj max-angle-curr))
  (format #t "~T~Toptions: ~D~%" (-> obj options))
  (format #t "~T~Tcam-entity: ~A~%" (-> obj cam-entity))
  (format #t "~T~Tvelocity: ~`vector`P~%" (-> obj velocity))
  (format #t "~T~Tdesired-pos: ~`vector`P~%" (-> obj desired-pos))
  (format #t "~T~Ttime-dist-too-far: ~D~%" (-> obj time-dist-too-far))
  (format #t "~T~Tlos-state: ~D~%" (-> obj los-state))
  (format #t "~T~Tgood-point: ~`vector`P~%" (-> obj good-point))
  (format #t "~T~Tlos-tgt-spline-pt: ~D~%" (-> obj los-tgt-spline-pt))
  (format #t "~T~Tlos-tgt-spline-pt-incarnation: ~D~%" (-> obj los-tgt-spline-pt-incarnation))
  (format #t "~T~Tlos-last-pos: ~`vector`P~%" (-> obj los-last-pos))
  (format #t "~T~Tintro-curve: #<curve @ #x~X>~%" (-> obj intro-curve))
  (format #t "~T~Tintro-offset: #<vector @ #x~X>~%" (-> obj intro-offset))
  (format #t "~T~Tintro-t: ~f~%" (-> obj intro-t))
  (format #t "~T~Tintro-t-step: ~f~%" (-> obj intro-t-step))
  (format #t "~T~Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
  (format #t "~T~Tspline-exists: ~A~%" (-> obj spline-exists))
  (format #t "~T~Tspline-curve: #<curve @ #x~X>~%" (-> obj spline-curve))
  (format #t "~T~Tspline-offset: #<vector @ #x~X>~%" (-> obj spline-offset))
  (format #t "~T~Tindex: #<cam-index @ #x~X>~%" (-> obj index))
  (format #t "~T~Tsaved-pt: #<vector @ #x~X>~%" (-> obj saved-pt))
  (format #t "~T~Tspline-tt: ~f~%" (-> obj spline-tt))
  (format #t "~T~Tspline-follow-dist: ~f~%" (-> obj spline-follow-dist))
  (format #t "~T~Tchange-event-from: #x~X~%" (-> obj change-event-from))
  (format #t "~T~Tenter-has-run: ~A~%" (-> obj enter-has-run))
  (format #t "~T~Tblend-from-type: ~D~%" (-> obj blend-from-type))
  (format #t "~T~Tblend-to-type: ~D~%" (-> obj blend-to-type))
  (format #t "~T~Thave-phony-joystick: ~A~%" (-> obj have-phony-joystick))
  (format #t "~T~Tphony-joystick-x: ~f~%" (-> obj phony-joystick-x))
  (format #t "~T~Tphony-joystick-y: ~f~%" (-> obj phony-joystick-y))
  (format #t "~T~Tstring-min-val: #<vector @ #x~X>~%" (-> obj string-min-val))
  (format #t "~T~Tstring-max-val: #<vector @ #x~X>~%" (-> obj string-max-val))
  (format #t "~T~Tstring-val-locked: ~A~%" (-> obj string-val-locked))
  obj
  )

;; definition of type camera-master
(deftype camera-master (process)
  ((master-options      uint32                           :offset-assert 112)
   (num-slaves          int32                            :offset-assert 116)
   (slave               (pointer camera-slave)   2       :offset-assert 120)
   (slave-options       uint32                           :offset-assert 128)
   (view-off-param-save float                            :offset-assert 132)
   (changer             uint32                           :offset-assert 136)
   (cam-entity          entity                           :offset-assert 140)
   (stringMinLength     float                            :offset-assert 144)
   (stringMaxLength     float                            :offset-assert 148)
   (stringMinHeight     float                            :offset-assert 152)
   (stringMaxHeight     float                            :offset-assert 156)
   (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)
   (stringCliffHeight   float                            :offset-assert 288)
   (no-intro            uint32                           :offset-assert 292)
   (force-blend         uint32                           :offset-assert 296)
   (force-blend-time    uint32                           :offset-assert 300)
   (local-down          vector                   :inline :offset-assert 304)
   (drawable-target     handle                           :offset-assert 320)
   (which-bone          int32                            :offset-assert 328)
   (pov-handle          handle                           :offset-assert 336)
   (pov-bone            int32                            :offset-assert 344)
   (being-attacked      symbol                           :offset-assert 348)
   (attack-start        time-frame                       :offset-assert 352)
   (on-ground           symbol                           :offset-assert 360)
   (under-water         int32                            :offset-assert 364)
   (on-pole             symbol                           :offset-assert 368)
   (tgt-rot-mat         matrix                   :inline :offset-assert 384)
   (tgt-face-mat        matrix                   :inline :offset-assert 448)
   (tpos-old            vector                   :inline :offset-assert 512)
   (tpos-curr           vector                   :inline :offset-assert 528)
   (target-height       float                            :offset-assert 544)
   (tpos-old-adj        vector                   :inline :offset-assert 560)
   (tpos-curr-adj       vector                   :inline :offset-assert 576)
   (tpos-tgt            vector                   :inline :offset-assert 592)
   (upspeed             float                            :offset-assert 608)
   (pitch-off           vector                   :inline :offset-assert 624)
   (foot-offset         float                            :offset-assert 640)
   (head-offset         float                            :offset-assert 644)
   (target-spline       tracking-spline          :inline :offset-assert 656)
   (ease-from           vector                   :inline :offset-assert 2304)
   (ease-t              float                            :offset-assert 2320)
   (ease-step           float                            :offset-assert 2324)
   (ease-to             vector                   :inline :offset-assert 2336)
   (outro-curve         curve                    :inline :offset-assert 2352)
   (outro-t             float                            :offset-assert 2372)
   (outro-t-step        float                            :offset-assert 2376)
   (outro-exit-value    float                            :offset-assert 2380)
   (water-drip-time     time-frame                       :offset-assert 2384)
   (water-drip          sparticle-launch-control         :offset-assert 2392)
   (water-drip-mult     float                            :offset-assert 2396)
   (water-drip-speed    float                            :offset-assert 2400)
   )
  :heap-base #x900
  :method-count-assert 14
  :size-assert         #x964
  :flag-assert         #xe09000964
  (:states
    cam-master-active
    list-keeper-active
    )
  )

;; definition for method 3 of type camera-master
(defmethod inspect camera-master ((obj camera-master))
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Tmaster-options: ~D~%" (-> obj master-options))
  (format #t "~T~Tnum-slaves: ~D~%" (-> obj num-slaves))
  (format #t "~T~Tslave[2] @ #x~X~%" (-> obj slave))
  (format #t "~T~Tslave-options: ~D~%" (-> obj slave-options))
  (format #t "~T~Tview-off-param-save: ~f~%" (-> obj view-off-param-save))
  (format #t "~T~Tchanger: #x~X~%" (-> obj changer))
  (format #t "~T~Tcam-entity: ~A~%" (-> obj cam-entity))
  (format #t "~T~TstringMinLength: ~f~%" (-> obj stringMinLength))
  (format #t "~T~TstringMaxLength: ~f~%" (-> obj stringMaxLength))
  (format #t "~T~TstringMinHeight: ~f~%" (-> obj stringMinHeight))
  (format #t "~T~TstringMaxHeight: ~f~%" (-> obj stringMaxHeight))
  (format #t "~T~Tstring-min: #<cam-vector-seeker @ #x~X>~%" (-> obj string-min))
  (format #t "~T~Tstring-max: #<cam-vector-seeker @ #x~X>~%" (-> obj string-max))
  (format #t "~T~Tstring-push-z: ~f~%" (-> obj string-push-z))
  (format #t "~T~TstringCliffHeight: ~f~%" (-> obj stringCliffHeight))
  (format #t "~T~Tno-intro: ~D~%" (-> obj no-intro))
  (format #t "~T~Tforce-blend: ~D~%" (-> obj force-blend))
  (format #t "~T~Tforce-blend-time: ~D~%" (-> obj force-blend-time))
  (format #t "~T~Tlocal-down: ~`vector`P~%" (-> obj local-down))
  (format #t "~T~Tdrawable-target: ~D~%" (-> obj drawable-target))
  (format #t "~T~Twhich-bone: ~D~%" (-> obj which-bone))
  (format #t "~T~Tpov-handle: ~D~%" (-> obj pov-handle))
  (format #t "~T~Tpov-bone: ~D~%" (-> obj pov-bone))
  (format #t "~T~Tbeing-attacked: ~A~%" (-> obj being-attacked))
  (format #t "~T~Tattack-start: ~D~%" (-> obj attack-start))
  (format #t "~T~Ton-ground: ~A~%" (-> obj on-ground))
  (format #t "~T~Tunder-water: ~D~%" (-> obj under-water))
  (format #t "~T~Ton-pole: ~A~%" (-> obj on-pole))
  (format #t "~T~Ttgt-rot-mat: ~`matrix`P~%" (-> obj tgt-rot-mat))
  (format #t "~T~Ttgt-face-mat: ~`matrix`P~%" (-> obj tgt-face-mat))
  (format #t "~T~Ttpos-old: ~`vector`P~%" (-> obj tpos-old))
  (format #t "~T~Ttpos-curr: ~`vector`P~%" (-> obj tpos-curr))
  (format #t "~T~Ttarget-height: ~f~%" (-> obj target-height))
  (format #t "~T~Ttpos-old-adj: ~`vector`P~%" (-> obj tpos-old-adj))
  (format #t "~T~Ttpos-curr-adj: ~`vector`P~%" (-> obj tpos-curr-adj))
  (format #t "~T~Ttpos-tgt: ~`vector`P~%" (-> obj tpos-tgt))
  (format #t "~T~Tupspeed: ~f~%" (-> obj upspeed))
  (format #t "~T~Tpitch-off: ~`vector`P~%" (-> obj pitch-off))
  (format #t "~T~Tfoot-offset: ~f~%" (-> obj foot-offset))
  (format #t "~T~Thead-offset: ~f~%" (-> obj head-offset))
  (format #t "~T~Ttarget-spline: #<tracking-spline @ #x~X>~%" (-> obj target-spline))
  (format #t "~T~Tease-from: #<vector @ #x~X>~%" (-> obj ease-from))
  (format #t "~T~Tease-t: ~f~%" (-> obj ease-t))
  (format #t "~T~Tease-step: ~f~%" (-> obj ease-step))
  (format #t "~T~Tease-to: #<vector @ #x~X>~%" (-> obj ease-to))
  (format #t "~T~Toutro-curve: #<curve @ #x~X>~%" (-> obj outro-curve))
  (format #t "~T~Toutro-t: ~f~%" (-> obj outro-t))
  (format #t "~T~Toutro-t-step: ~f~%" (-> obj outro-t-step))
  (format #t "~T~Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
  (format #t "~T~Twater-drip-time: ~D~%" (-> obj water-drip-time))
  (format #t "~T~Twater-drip: ~A~%" (-> obj water-drip))
  (format #t "~T~Twater-drip-mult: ~f~%" (-> obj water-drip-mult))
  (format #t "~T~Twater-drip-speed: ~f~%" (-> obj water-drip-speed))
  obj
  )

;; failed to figure out what this is:
0