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

;; name: camera-h.gc
;; name in dgo: camera-h
;; dgos: GAME, ENGINE

;; 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          uint64  :offset-assert 16)
   (default-string-max-y    float   :offset-assert 24)
   (default-string-min-y    float   :offset-assert 28)
   (default-string-max-z    float   :offset-assert 32)
   (default-string-min-z    float   :offset-assert 36)
   (default-string-push-z   float   :offset-assert 40)
   (default-tilt-adjust     float   :offset-assert 44)
   )
  :method-count-assert 9
  :size-assert         #x30
  :flag-assert         #x900000030
  )

;; 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 #x4b
         :default-string-max-y 12288.0
         :default-string-min-y 4096.0
         :default-string-max-z 51200.0
         :default-string-min-z 20480.0
         :default-string-push-z 40960.0
         :default-tilt-adjust -1183.289
         )
  )

;; definition of type cam-index
(deftype cam-index (structure)
  ((flags uint32    :offset-assert 0)
   (vec   uint128 2 :offset-assert 16)
   )
  :method-count-assert 11
  :size-assert         #x30
  :flag-assert         #xb00000030
  (:methods
   (dummy-9 () none 9)
   (dummy-10 () none 10)
   )
  )
;; 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 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 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
   (dummy-9 () none 9)
   (dummy-10 () none 10)
   (dummy-11 () none 11)
   (dummy-12 () none 12)
   (dummy-13 () none 13)
   (dummy-14 () none 14)
   (dummy-15 () none 15)
   (dummy-16 () none 16)
   (dummy-17 () none 17)
   (dummy-18 () none 18)
   (dummy-19 () none 19)
   (dummy-20 () none 20)
   (dummy-21 () none 21)
   (dummy-22 () none 22)
   (dummy-23 () none 23)
   )
  )

;; 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)
   (TODO-RENAME-11 (_type_ float) none 11)
   (TODO-RENAME-12 (_type_ float) float 12)
   )
  )

;; 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)
  (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))
  (none)
  )

;; definition for method 11 of type cam-float-seeker
;; INFO: Return type mismatch int vs none.
(defmethod TODO-RENAME-11 cam-float-seeker ((obj cam-float-seeker) (arg0 float))
  (let ((f0-0 0.0))
    )
  (let ((f0-1 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) (-> *display* time-adjust-ratio)))))
      (set! (-> obj vel) (+ (-> 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) (-> *display* time-adjust-ratio))))
    (set! (-> obj value) (+ (-> obj value) f0-10))
    )
  (none)
  )

;; definition for method 12 of type cam-float-seeker
(defmethod TODO-RENAME-12 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
   (TODO-RENAME-9 (_type_ vector float float float) none 9)
   (TODO-RENAME-10 (_type_ vector) none 10)
   )
  )

;; definition for method 9 of type cam-vector-seeker
;; INFO: Return type mismatch int vs none.
;; Used lq/sq
(defmethod TODO-RENAME-9 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)
  (none)
  )
 

;; definition for method 10 of type cam-vector-seeker
;; INFO: Return type mismatch int vs none.
;; TODO - vector-float*! replacement
(defmethod TODO-RENAME-10 cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
    (init-vf0-vector)
    (let ((gp-0 (new 'stack-no-clear 'vector)))
      (let ((f0-0 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))))
        (let ((v1-3 gp-0))
          (let ((a0-5 gp-0)
                (f0-3 (* (-> obj accel) (-> *display* time-adjust-ratio)))
                )
            (.lvf vf1 (&-> a0-5 quad))
            (let ((a0-6 f0-3))
              (.mov vf2 a0-6)
              )
            )
          (.add.x.vf vf1 vf0 vf0 :mask #b1000)
          (.mul.x.vf vf1 vf1 vf2 :mask #b111)
          (.svf (&-> v1-3 quad) vf1)
          )
        (vector+! (-> obj vel) (-> obj vel) gp-0)
        (let ((f0-4 (vector-length (-> obj vel)))
              (f1-2 (fmin f30-1 (-> obj max-vel)))
              )
          (when (< f1-2 f0-4)
            (let ((v1-6 (-> obj vel)))
              (let ((a0-9 (-> obj vel))
                    (f0-5 (/ f1-2 f0-4))
                    )
                (.lvf vf1 (&-> a0-9 quad))
                (let ((a0-10 f0-5))
                  (.mov vf2 a0-10)
                  )
                )
              (.add.x.vf vf1 vf0 vf0 :mask #b1000)
              (.mul.x.vf vf1 vf1 vf2 :mask #b111)
              (.svf (&-> v1-6 quad) vf1)
              )
            )
          )
        )
      (let ((v1-7 gp-0))
        (let ((a0-11 (-> obj vel))
              (f0-6 (-> *display* time-adjust-ratio))
              )
          (.lvf vf1 (&-> a0-11 quad))
          (let ((a0-12 f0-6))
            (.mov vf2 a0-12)
            )
          )
        (.add.x.vf vf1 vf0 vf0 :mask #b1000)
        (.mul.x.vf vf1 vf1 vf2 :mask #b111)
        (.svf (&-> v1-7 quad) vf1)
        )
      (vector+! (-> obj value) (-> obj value) gp-0)
      )
    (let ((v0-2 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 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
  )

;; 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)
   (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                    basic                        :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                     uint32                       :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             uint32                       :offset-assert 2488)
   (enter-has-run                 basic                        :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
  )

;; definition of type camera-master
(deftype camera-master (process)
  ((master-options      uint32                    :offset-assert 112)
   (num-slaves          int32                     :offset-assert 116)
   (slave               basic             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          basic                     :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     uint64                    :offset-assert 320)
   (which-bone          int32                     :offset-assert 328)
   (pov-handle          uint64                    :offset-assert 336)
   (pov-bone            int32                     :offset-assert 344)
   (being-attacked      basic                     :offset-assert 348)
   (attack-start        uint64                    :offset-assert 352)
   (on-ground           basic                     :offset-assert 360)
   (under-water         int32                     :offset-assert 364)
   (on-pole             basic                     :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     uint64                    :offset-assert 2384)
   (water-drip          basic                     :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
  )