jak-project/goal_src/engine/camera/camera-h.gc

;;-*-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    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 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 (meters 3.0)
         :default-string-min-y (meters 1.0)
         :default-string-max-z (meters 12.5)
         :default-string-min-z (meters 5.0)
         :default-string-push-z (meters 10.0)
         :default-tilt-adjust (degrees -6.5000005)
         )
  )

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

;; cam-float-seeker moves value toward target in a smooth way, with second order dynamics.
;; The acceleration is proportional to the error.
;; This isn't stable by itself, so there is a velocity limit (proportional to distance) applied.
(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 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)
  )

(defmethod update! cam-float-seeker ((obj cam-float-seeker) (offset float))
  "Seek toward target + offset"
  (let* ((pos-error (- (+ (-> obj target) offset) (-> obj value)))
         ;; the velocity limit based on distance to target
         (partial-velocity-limit (* (-> obj max-partial) (fabs pos-error)))
         )

    ;; apply acceleration to velocity
    (let ((daccel (* pos-error (* (-> obj accel) (-> *display* time-adjust-ratio)))))
      (+! (-> obj vel) daccel)
      )

    ;; limit velocity using max-vel and the partial limit
    (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)))
          )
      )
    )

  ;; update position
  (let ((dpos (* (-> obj vel) (-> *display* time-adjust-ratio))))
    (+! (-> obj value) dpos)
    )
  (none)
  )

(defmethod jump-to-target! cam-float-seeker ((obj cam-float-seeker) (arg0 float))
  "Jump to target + arg0 and set velocity to 0"
  (set! (-> obj value) (+ (-> obj target) arg0))
  (let ((f0-2 0.0))
    (set! (-> obj vel) f0-2)
    f0-2
    )
  )

;; very similar to cam-float-seeker but works on an
;; entire vector.
(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)
   )
  )

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

(defmethod update! cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector))
  (let ((gp-0 (new 'stack-no-clear 'vector)))
    (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)
  )

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