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

;; name: transformq.gc
;; name in dgo: transformq
;; dgos: GAME, ENGINE

;; definition for method 2 of type transformq
(defmethod print transformq ((obj transformq))
  (format #t "#<transformq @ #x~X~%" obj)
  (format
   #t
   "~T~Ttrans:~F ~F ~F ~F ~%"
   (-> obj trans x)
   (-> obj trans y)
   (-> obj trans z)
   (-> obj trans w)
   )
  (format
   #t
   "~T~Tquat:  ~F ~F ~F ~F ~%"
   (-> obj rot x)
   (-> obj rot y)
   (-> obj rot z)
   (-> obj rot w)
   )
  (format
   #t
   "~T~Tscale:~F ~F ~F ~F>"
   (-> obj scale x)
   (-> obj scale y)
   (-> obj scale z)
   (-> obj scale w)
   )
  obj
  )

;; definition for method 27 of type trsqv
;; INFO: Return type mismatch vector vs quaternion.
(defmethod get-quaternion trsqv ((obj trsqv))
  (the-as quaternion (-> obj rot))
  )

;; definition for method 18 of type trsqv
(defmethod set-quaternion!-18 trsqv ((obj trsqv) (arg0 quaternion))
  (quaternion-copy! (get-quaternion obj) arg0)
  )

;; definition for method 21 of type trsqv
(defmethod rot->dir-targ!-21 trsqv ((obj trsqv))
  (quaternion-copy! (-> obj dir-targ) (get-quaternion obj))
  )

;; definition for method 22 of type trsqv
(defmethod y-angle trsqv ((obj trsqv))
  (quaternion-y-angle (get-quaternion obj))
  )

;; definition for method 9 of type trsqv
(defmethod TODO-RENAME-9 trsqv ((obj trsqv) (arg0 vector) (arg1 float) (arg2 int))
  (let*
   ((f0-0
     (deg-diff
      (quaternion-y-angle (the-as quaternion (-> obj rot)))
      (vector-y-angle arg0)
      )
     )
    (f1-2
     (fmin
      (* arg1 (-> *display* seconds-per-frame))
      (/ (* 5.0 (fabs f0-0)) (the float arg2))
      )
     )
    (f30-0 (fmax (fmin f0-0 f1-2) (- f1-2)))
    )
   (let ((f0-2 (-> obj old-y-angle-diff)))
    (set! f30-0 (cond
                 ((or
                   (= f0-2 0.0)
                   (and (< 0.0 f30-0) (< 0.0 f0-2))
                   (or
                    (and (< f30-0 0.0) (< f0-2 0.0))
                    (>=
                     (the-as
                      int
                      (-
                       (-> *display* base-frame-counter)
                       (-> obj angle-change-time)
                       )
                      )
                     60
                     )
                    )
                   )
                  (set!
                   (-> obj angle-change-time)
                   (-> *display* base-frame-counter)
                   )
                  f30-0
                  )
                 (else
                  (* 0.000000001 f30-0)
                  )
                 )
     )
    )
   (set! (-> obj old-y-angle-diff) f30-0)
   (let ((a1-2 (get-quaternion obj)))
    (quaternion-rotate-y! a1-2 a1-2 f30-0)
    )
   )
  )

;; definition for method 10 of type trsqv
(defmethod TODO-RENAME-10 trsqv ((obj trsqv) (arg0 vector))
  (let ((s3-0 (get-quaternion obj)))
   (forward-up-nopitch->quaternion
    s3-0
    (vector-normalize-copy! (new 'stack-no-clear 'vector) arg0 1.0)
    (vector-y-quaternion! (new 'stack-no-clear 'vector) s3-0)
    )
   )
  )

;; definition for method 11 of type trsqv
(defmethod TODO-RENAME-11 trsqv ((obj trsqv) (arg0 vector) (arg1 float) (arg2 int))
  (rlet ((vf0 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (let* ((v1-0 obj)
          (t9-0 (method-of-object v1-0 TODO-RENAME-9))
          (t0-1 (new 'stack-no-clear 'vector))
          )
    (let ((a0-1 (-> obj trans)))
     (.lvf vf4 (&-> arg0 quad))
     (.lvf vf5 (&-> a0-1 quad))
     )
    (.mov.vf vf6 vf0 :mask #b1000)
    (.sub.vf vf6 vf4 vf5 :mask #b111)
    (.svf (&-> t0-1 quad) vf6)
    (t9-0 v1-0 t0-1 arg1 arg2)
    )
   )
  )

;; definition for method 12 of type trsqv
(defmethod TODO-RENAME-12 trsqv ((obj trsqv) (arg0 vector))
  (rlet ((vf0 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (let* ((s3-0 (get-quaternion obj))
          (gp-0 forward-up-nopitch->quaternion)
          (s5-0 s3-0)
          (t9-1 vector-normalize!)
          (a0-2 (new 'stack-no-clear 'vector))
          )
    (let ((v1-1 (-> obj trans)))
     (.lvf vf4 (&-> arg0 quad))
     (.lvf vf5 (&-> v1-1 quad))
     )
    (.mov.vf vf6 vf0 :mask #b1000)
    (.sub.vf vf6 vf4 vf5 :mask #b111)
    (.svf (&-> a0-2 quad) vf6)
    (gp-0
     s5-0
     (t9-1 a0-2 1.0)
     (vector-y-quaternion! (new 'stack-no-clear 'vector) s3-0)
     )
    )
   )
  )

;; definition for method 13 of type trsqv
(defmethod
  TODO-RENAME-13
  trsqv
  ((obj trsqv) (arg0 float) (arg1 float) (arg2 int))
  (let ((s3-0 (method-of-object obj TODO-RENAME-9))
        (s2-0 (new 'stack-no-clear 'vector))
        )
   (set! (-> s2-0 x) (sin arg0))
   (set! (-> s2-0 y) 0.0)
   (set! (-> s2-0 z) (cos arg0))
   (set! (-> s2-0 w) 1.0)
   (s3-0 obj s2-0 arg1 arg2)
   )
  )

;; definition for method 14 of type trsqv
(defmethod TODO-RENAME-14 trsqv ((obj trsqv) (arg0 float))
  (let ((s5-0 (method-of-object obj TODO-RENAME-19))
        (s4-0 (new 'stack-no-clear 'vector))
        )
   (set! (-> s4-0 x) (sin arg0))
   (set! (-> s4-0 y) 0.0)
   (set! (-> s4-0 z) (cos arg0))
   (set! (-> s4-0 w) 1.0)
   (s5-0 obj s4-0)
   )
  )

;; definition for method 15 of type trsqv
(defmethod TODO-RENAME-15 trsqv ((obj trsqv) (arg0 float))
  (TODO-RENAME-VECTOR-DOT-16 obj arg0)
  )

;; definition for method 16 of type trsqv
(defmethod TODO-RENAME-VECTOR-DOT-16 trsqv ((obj trsqv) (arg0 float))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         )
   (let* ((s5-0 (get-quaternion obj))
          (s1-0 (-> *standard-dynamics* gravity-normal))
          (s3-0 (quaternion->matrix (new 'stack-no-clear 'matrix) s5-0))
          )
    (let ((s4-0 (&-> s3-0 data 8)))
     (vector-normalize!
      (vector-flatten!
       (the-as vector (&-> s3-0 data 4))
       s1-0
       (the-as vector s4-0)
       )
      1.0
      )
     (let ((a0-4 (-> s3-0 data)))
      (let ((v1-3 (&-> s3-0 data 4)))
       (.lvf vf1 v1-3)
       )
      (.lvf vf2 s4-0)
      (.outer.product.vf vf3 vf1 vf2)
      (.svf (the-as (pointer uint128) (&-> a0-4 0)) vf3)
      )
     )
    (let ((a1-5 (matrix-rotate-z! (new 'stack-no-clear 'matrix) arg0)))
     (matrix*! s3-0 a1-5 s3-0)
     )
    (matrix->quaternion s5-0 s3-0)
    )
   )
  )

;; definition for method 25 of type trsqv
;; WARN: Unsupported inline assembly instruction kind - [mula.s f0, f3]
;; WARN: Unsupported inline assembly instruction kind - [madda.s f1, f4]
;; WARN: Unsupported inline assembly instruction kind - [madd.s f0, f2, f5]
;; WARN: Unsupported inline assembly instruction kind - [mula.s f1, f4]
;; WARN: Unsupported inline assembly instruction kind - [madda.s f2, f5]
;; WARN: Unsupported inline assembly instruction kind - [madd.s f1, f3, f6]
(defmethod TODO-VECTOR-MATH-ISSUES-25 trsqv ((obj trsqv))
  (local-vars (f0-1 float) (f1-2 float))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         )
   (let* ((s5-0 (get-quaternion obj))
          (gp-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) s5-0))
          (s5-1 (vector-y-quaternion! (new 'stack-no-clear 'vector) s5-0))
          (a1-2 (-> *standard-dynamics* gravity-normal))
          (v1-2
           (vector-normalize!
            (vector-flatten! (new 'stack-no-clear 'vector) a1-2 gp-0)
            1.0
            )
           )
          )
    (let ((f0-2 (vector-dot v1-2 s5-1)))
     (let ((a0-7 (new 'stack-no-clear 'quaternion)))
      (.lvf vf1 (&-> v1-2 quad))
      (.lvf vf2 (&-> s5-1 quad))
      (.outer.product.vf vf3 vf1 vf2)
      (.svf (&-> a0-7 vec quad) vf3)
      (let ((f1-2 (vector-dot a0-7 gp-0)))
       (if (< f1-2 0.0)
        (- (acos f0-2))
        (acos f0-2)
        )
       )
      )
     )
    )
   )
  )

;; definition for method 17 of type trsqv
;; Used lq/sq
(defmethod
  TODO-RENAME-17
  trsqv
  ((obj trsqv) (arg0 quaternion) (arg1 float) (arg2 float))
  (local-vars (sv-96 vector))
  (let ((gp-0 (get-quaternion obj)))
   (let ((s5-0 (new 'stack-no-clear 'quaternion)))
    (when (< 0.0 arg2)
     (let ((s1-0 quaternion-from-two-vectors-max-angle!)
           (s0-0 s5-0)
           )
      (set! sv-96 (vector-y-quaternion! (new 'stack-no-clear 'vector) gp-0))
      (let ((a2-1 (vector-y-quaternion! (new 'stack-no-clear 'vector) arg0))
            (a3-1 (* arg2 (-> *display* seconds-per-frame)))
            )
       (s1-0 s0-0 sv-96 a2-1 a3-1)
       )
      )
     (quaternion-normalize! (quaternion*! gp-0 s5-0 gp-0))
     )
    (let ((v0-6 (when (< 0.0 arg1)
                 (quaternion-from-two-vectors-max-angle!
                  s5-0
                  (vector-z-quaternion! (new 'stack-no-clear 'vector) gp-0)
                  (vector-z-quaternion! (new 'stack-no-clear 'vector) arg0)
                  (* arg1 (-> *display* seconds-per-frame))
                  )
                 (quaternion-normalize! (quaternion*! gp-0 s5-0 gp-0))
                 )
           )
          )
     )
    )
   gp-0
   )
  )

;; definition for method 19 of type trsqv
(defmethod TODO-RENAME-19 trsqv ((obj trsqv) (arg0 vector))
  (forward-up->quaternion
   (get-quaternion obj)
   (vector-normalize-copy! (new 'stack-no-clear 'vector) arg0 1.0)
   (new 'static 'vector :y 1.0 :w 1.0)
   )
  )

;; definition for method 20 of type trsqv
(defmethod TODO-RENAME-20 trsqv ((obj trsqv) (arg0 vector))
  (rlet ((vf0 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (let ((gp-0 forward-up->quaternion)
         (s3-0 (get-quaternion obj))
         (t9-1 vector-normalize!)
         (a0-2 (new 'stack-no-clear 'vector))
         )
    (let ((v1-1 (-> obj trans)))
     (.lvf vf4 (&-> arg0 quad))
     (.lvf vf5 (&-> v1-1 quad))
     )
    (.mov.vf vf6 vf0 :mask #b1000)
    (.sub.vf vf6 vf4 vf5 :mask #b111)
    (.svf (&-> a0-2 quad) vf6)
    (gp-0 s3-0 (t9-1 a0-2 1.0) (new 'static 'vector :y 1.0 :w 1.0))
    )
   )
  )

;; definition for function transformq-copy!
;; Used lq/sq
(defun transformq-copy! ((arg0 transformq) (arg1 transformq))
  (set! (-> arg0 trans quad) (-> arg1 trans quad))
  (set! (-> arg0 rot quad) (-> arg1 rot quad))
  (set! (-> arg0 scale quad) (-> arg1 scale quad))
  arg0
  )

;; definition for function matrix<-transformq!
;; Used lq/sq
(defun matrix<-transformq! ((arg0 matrix) (arg1 transformq))
  (local-vars (v1-1 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
   (cond
    (#f
     (set! (-> arg0 vector 3 quad) (-> arg1 trans quad))
     )
    (else
     (.lvf vf1 (&-> arg1 scale quad))
     (.lvf vf2 (&-> arg1 trans quad))
     (.lvf vf3 (&-> arg0 vector 0 quad))
     (.lvf vf4 (&-> arg0 vector 1 quad))
     (.lvf vf5 (&-> arg0 vector 2 quad))
     (.mov.vf vf2 vf0 :mask #b1000)
     (.mul.x.vf vf3 vf3 vf1)
     (.mul.y.vf vf4 vf4 vf1)
     (.mul.z.vf vf5 vf5 vf1)
     (.svf (&-> arg0 vector 3 quad) vf2)
     (.svf (&-> arg0 vector 0 quad) vf3)
     (.svf (&-> arg0 vector 1 quad) vf4)
     (.svf (&-> arg0 vector 2 quad) vf5)
     (.mov v1-1 vf5)
     )
    )
   arg0
   )
  )

;; definition for function matrix<-no-trans-transformq!
(defun matrix<-no-trans-transformq! ((arg0 matrix) (arg1 transformq))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
   (.lvf vf1 (&-> arg1 scale quad))
   (.lvf vf3 (&-> arg0 vector 0 quad))
   (.lvf vf4 (&-> arg0 vector 1 quad))
   (.lvf vf5 (&-> arg0 vector 2 quad))
   (.mov.vf vf2 vf0)
   (.mul.x.vf vf3 vf3 vf1)
   (.mul.y.vf vf4 vf4 vf1)
   (.mul.z.vf vf5 vf5 vf1)
   (.svf (&-> arg0 vector 3 quad) vf2)
   (.svf (&-> arg0 vector 0 quad) vf3)
   (.svf (&-> arg0 vector 1 quad) vf4)
   (.svf (&-> arg0 vector 2 quad) vf5)
   arg0
   )
  )

;; definition for function matrix<-transformq+trans!
(defun matrix<-transformq+trans! ((arg0 matrix) (arg1 transformq) (arg2 vector))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
   (.lvf vf1 (&-> arg1 scale quad))
   (.lvf vf2 (&-> arg1 trans quad))
   (.lvf vf6 (&-> arg2 quad))
   (.lvf vf3 (&-> arg0 vector 0 quad))
   (.lvf vf4 (&-> arg0 vector 1 quad))
   (.lvf vf5 (&-> arg0 vector 2 quad))
   (.mov.vf vf2 vf0 :mask #b1000)
   (.mul.x.vf vf3 vf3 vf1)
   (.mul.y.vf vf4 vf4 vf1)
   (.mul.z.vf vf5 vf5 vf1)
   (.mul.x.vf acc vf3 vf6)
   (.add.mul.y.vf acc vf4 vf6 acc)
   (.add.mul.z.vf acc vf5 vf6 acc)
   (.add.mul.w.vf vf2 vf2 vf0 acc :mask #b111)
   (.svf (&-> arg0 vector 3 quad) vf2)
   (.svf (&-> arg0 vector 0 quad) vf3)
   (.svf (&-> arg0 vector 1 quad) vf4)
   (.svf (&-> arg0 vector 2 quad) vf5)
   arg0
   )
  )

;; definition for function matrix<-transformq+world-trans!
(defun
  matrix<-transformq+world-trans!
  ((arg0 matrix) (arg1 transformq) (arg2 vector))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
   (.lvf vf1 (&-> arg1 scale quad))
   (.lvf vf2 (&-> arg1 trans quad))
   (.lvf vf6 (&-> arg2 quad))
   (.lvf vf3 (&-> arg0 vector 0 quad))
   (.lvf vf4 (&-> arg0 vector 1 quad))
   (.lvf vf5 (&-> arg0 vector 2 quad))
   (.mov.vf vf2 vf0 :mask #b1000)
   (.mul.x.vf vf3 vf3 vf1)
   (.mul.y.vf vf4 vf4 vf1)
   (.mul.z.vf vf5 vf5 vf1)
   (.add.vf vf2 vf2 vf6 :mask #b111)
   (.svf (&-> arg0 vector 3 quad) vf2)
   (.svf (&-> arg0 vector 0 quad) vf3)
   (.svf (&-> arg0 vector 1 quad) vf4)
   (.svf (&-> arg0 vector 2 quad) vf5)
   arg0
   )
  )

;; definition for function matrix<-parented-transformq!
(defun
  matrix<-parented-transformq!
  ((arg0 matrix) (arg1 transformq) (arg2 quaternion))
  (local-vars (v1-1 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         )
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (quaternion->matrix arg0 (the-as quaternion (-> arg1 rot)))
   (let ((v1-0 (new 'stack-no-clear 'quaternion)))
    (set! (-> v1-0 x) (/ 1.0 (-> arg2 x)))
    (set! (-> v1-0 y) (/ 1.0 (-> arg2 y)))
    (set! (-> v1-0 z) (/ 1.0 (-> arg2 z)))
    (.lvf vf1 (&-> arg1 scale quad))
    (.lvf vf2 (&-> arg1 trans quad))
    (.mov.vf vf2 vf0 :mask #b1000)
    (.lvf vf4 (&-> arg0 vector 0 quad))
    (.lvf vf5 (&-> arg0 vector 1 quad))
    (.lvf vf6 (&-> arg0 vector 2 quad))
    (.mul.x.vf vf4 vf4 vf1)
    (.mul.y.vf vf5 vf5 vf1)
    (.mul.z.vf vf6 vf6 vf1)
    (.lvf vf3 (&-> v1-0 vec quad))
    )
   (.mul.vf vf4 vf4 vf3)
   (.mul.vf vf5 vf5 vf3)
   (.mul.vf vf6 vf6 vf3)
   (.svf (&-> arg0 vector 3 quad) vf2)
   (.svf (&-> arg0 vector 0 quad) vf4)
   (.svf (&-> arg0 vector 1 quad) vf5)
   (.svf (&-> arg0 vector 2 quad) vf6)
   (.mov v1-1 vf6)
   arg0
   )
  )