jak-project/test/decompiler/reference/jak1/engine/math/quaternion_REF.gc

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

;; definition for method 3 of type quaternion
(defmethod inspect ((this quaternion))
  (format #t "[~8x] quaternion~%" this)
  (format #t "~T[~F] [~F] [~F] [~F]~%" (-> this x) (-> this y) (-> this z) (-> this w))
  (let ((f0-5 (/ 1.0 (sqrtf (+ (* (-> this x) (-> this x)) (* (-> this y) (-> this y)) (* (-> this z) (-> this z))))))
        )
    (format #t "~Taxis: ~F ~F ~F" (* f0-5 (-> this x)) (* f0-5 (-> this y)) (* f0-5 (-> this z)))
    )
  (let ((f0-9 (* 2.0 (acos (-> this w)))))
    (format #t "~T~Tangle: (deg ~R)~%" f0-9)
    )
  this
  )

;; definition for function quaternion-axis-angle!
(defun quaternion-axis-angle! ((quat quaternion) (x float) (y float) (z float) (angle float))
  (let* ((f28-0 (/ angle 2))
         (f30-0 (sin f28-0))
         (f0-1 (cos f28-0))
         )
    (set! (-> quat x) (* x f30-0))
    (set! (-> quat y) (* y f30-0))
    (set! (-> quat z) (* z f30-0))
    (set! (-> quat w) f0-1)
    )
  quat
  )

;; definition for function quaternion-vector-angle!
(defun quaternion-vector-angle! ((quat quaternion) (axis vector) (angle float))
  (let* ((f28-0 (/ angle 2))
         (f30-0 (sin f28-0))
         (f0-1 (cos f28-0))
         )
    (set! (-> quat x) (* (-> axis x) f30-0))
    (set! (-> quat y) (* (-> axis y) f30-0))
    (set! (-> quat z) (* (-> axis z) f30-0))
    (set! (-> quat w) f0-1)
    )
  quat
  )

;; definition for function vector-angle<-quaternion!
(defun vector-angle<-quaternion! ((arg0 vector) (arg1 quaternion))
  (let ((f30-0 (/ 1.0 (sqrtf (- 1.0 (square (-> arg1 w))))))
        (f0-3 (* 2.0 (acos-rad (-> arg1 w))))
        )
    (set! (-> arg0 x) (* (-> arg1 x) f30-0))
    (set! (-> arg0 y) (* (-> arg1 y) f30-0))
    (set! (-> arg0 z) (* (-> arg1 z) f30-0))
    (set! (-> arg0 w) f0-3)
    )
  arg0
  )

;; definition for function quaternion-zero!
;; INFO: Used lq/sq
(defun quaternion-zero! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  arg0
  )

;; definition for function quaternion-identity!
;; INFO: Used lq/sq
(defun quaternion-identity! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  (set! (-> arg0 w) 1.0)
  arg0
  )

;; definition for function quaternion-i!
;; INFO: Used lq/sq
(defun quaternion-i! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  (set! (-> arg0 x) 1.0)
  arg0
  )

;; definition for function quaternion-j!
;; INFO: Used lq/sq
(defun quaternion-j! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  (set! (-> arg0 y) 1.0)
  arg0
  )

;; definition for function quaternion-k!
;; INFO: Used lq/sq
(defun quaternion-k! ((arg0 quaternion))
  (set! (-> arg0 vec quad) (the-as uint128 0))
  (set! (-> arg0 z) 1.0)
  arg0
  )

;; definition for function quaternion-copy!
;; INFO: Used lq/sq
(defun quaternion-copy! ((arg0 quaternion) (arg1 quaternion))
  (set! (-> arg0 vec quad) (-> arg1 vec quad))
  arg0
  )

;; definition for function quaternion-set!
(defun quaternion-set! ((arg0 quaternion) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
  (set! (-> arg0 x) arg1)
  (set! (-> arg0 y) arg2)
  (set! (-> arg0 z) arg3)
  (set! (-> arg0 w) arg4)
  arg0
  )

;; definition for function quaternion+!
(defun quaternion+! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
    (.lvf vf1 (&-> arg1 vec quad))
    (.lvf vf2 (&-> arg2 vec quad))
    (.add.vf vf1 vf1 vf2)
    (.svf (&-> arg0 vec quad) vf1)
    arg0
    )
  )

;; definition for function quaternion-!
(defun quaternion-! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
    (.lvf vf1 (&-> arg1 vec quad))
    (.lvf vf2 (&-> arg2 vec quad))
    (.sub.vf vf1 vf1 vf2)
    (.svf (&-> arg0 vec quad) vf1)
    arg0
    )
  )

;; definition for function quaternion-negate!
;; ERROR: Bad vector register dependency: vf2
(defun quaternion-negate! ((arg0 quaternion) (arg1 quaternion))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
    (.lvf vf1 (&-> arg1 vec quad))
    (.sub.vf vf2 vf2 vf2)
    (.sub.vf vf1 vf2 vf1)
    (.svf (&-> arg0 vec quad) vf1)
    arg0
    )
  )

;; definition for function quaternion-conjugate!
;; ERROR: Bad vector register dependency: vf2
(defun quaternion-conjugate! ((arg0 quaternion) (arg1 quaternion))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
    (.lvf vf1 (&-> arg1 vec quad))
    (.sub.vf vf2 vf2 vf2)
    (.sub.vf.xyz vf2 vf2 vf1)
    (.add.vf.w vf2 vf2 vf1)
    (.svf (&-> arg0 vec quad) vf2)
    arg0
    )
  )

;; definition for function quaternion-float*!
(defun quaternion-float*! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
    (.lvf vf1 (&-> arg1 vec quad))
    (.mov vf2 arg2)
    (.mul.x.vf vf1 vf1 vf2)
    (.svf (&-> arg0 vec quad) vf1)
    arg0
    )
  )

;; definition for function quaternion-float/!
(defun quaternion-float/! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((f0-1 (/ 1.0 arg2)))
    (quaternion-float*! arg0 arg1 f0-1)
    )
  arg0
  )

;; definition for function quaternion-norm2
(defun quaternion-norm2 ((arg0 quaternion))
  (local-vars (v0-0 float))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg0 vec quad))
    (.mul.vf vf1 vf1 vf1)
    (.add.z.vf.w acc vf1 vf1)
    (.add.mul.y.vf.w acc vf0 vf1 acc)
    (.add.mul.x.vf.w vf1 vf0 vf1 acc)
    (.add.w.vf vf1 vf0 vf1)
    (.mov v0-0 vf1)
    v0-0
    )
  )

;; definition for function quaternion-norm
(defun quaternion-norm ((arg0 quaternion))
  (local-vars (v1-1 float))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg0 vec quad))
    (.mul.vf vf1 vf1 vf1)
    (.add.z.vf.w acc vf1 vf1)
    (.add.mul.y.vf.w acc vf0 vf1 acc)
    (.add.mul.x.vf.w vf1 vf0 vf1 acc)
    (.add.w.vf vf1 vf0 vf1)
    (.mov v1-1 vf1)
    (sqrtf v1-1)
    )
  )

;; definition for function quaternion-normalize!
(defun quaternion-normalize! ((arg0 quaternion))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg0 vec quad))
    (.mul.vf vf2 vf1 vf1)
    (.add.z.vf.w acc vf2 vf2)
    (.add.mul.y.vf.w acc vf0 vf2 acc)
    (.add.mul.x.vf.w vf2 vf0 vf2 acc)
    (.isqrt.vf Q vf0 vf2 :fsf #b11 :ftf #b11)
    (.wait.vf)
    (.mul.vf vf2 vf1 Q)
    (.nop.vf)
    (.nop.vf)
    (.svf (&-> arg0 vec quad) vf2)
    arg0
    )
  )

;; definition for function quaternion-inverse!
;; ERROR: Bad vector register dependency: vf3
(defun quaternion-inverse! ((arg0 quaternion) (arg1 quaternion))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg1 vec quad))
    (.mul.vf vf2 vf1 vf1)
    (.sub.vf vf3 vf3 vf3)
    (.add.z.vf.w acc vf2 vf2)
    (.add.mul.y.vf.w acc vf0 vf2 acc)
    (.add.mul.x.vf.w vf2 vf0 vf2 acc)
    (.sub.vf.xyz vf3 vf3 vf1)
    (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b11)
    (.add.vf.w vf3 vf3 vf1)
    (.wait.vf)
    (.mul.vf vf3 vf3 Q)
    (.nop.vf)
    (.nop.vf)
    (.svf (&-> arg0 vec quad) vf3)
    arg0
    )
  )

;; definition for function quaternion-dot
(defun quaternion-dot ((arg0 quaternion) (arg1 quaternion))
  (local-vars (v0-0 float))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg0 vec quad))
    (.lvf vf2 (&-> arg1 vec quad))
    (.mul.vf vf1 vf1 vf2)
    (.add.z.vf.w acc vf1 vf1)
    (.add.mul.y.vf.w acc vf0 vf1 acc)
    (.add.mul.x.vf.w vf1 vf0 vf1 acc)
    (.add.w.vf vf1 vf0 vf1)
    (.mov v0-0 vf1)
    v0-0
    )
  )

;; definition for function quaternion*!
(defun quaternion*! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg1 vec quad))
    (.lvf vf2 (&-> arg2 vec quad))
    (.sub.vf.w vf4 vf0 vf0)
    (.mul.vf vf3 vf1 vf2)
    (.outer.product.a.vf acc vf1 vf2)
    (.outer.product.b.vf vf4 vf2 vf1 acc)
    (.mul.w.vf acc vf1 vf2)
    (.add.mul.w.vf acc vf2 vf1 acc)
    (.sub.mul.w.vf.w acc vf0 vf3 acc)
    (.sub.mul.z.vf.w acc vf0 vf3 acc)
    (.sub.mul.y.vf.w acc vf0 vf3 acc)
    (.sub.mul.x.vf.w acc vf0 vf3 acc)
    (.add.mul.w.vf vf1 vf4 vf0 acc)
    (.svf (&-> arg0 vec quad) vf1)
    arg0
    )
  )

;; definition for function quaternion-right-mult-matrix!
(defun quaternion-right-mult-matrix! ((arg0 matrix) (arg1 quaternion))
  (let ((f3-0 (-> arg1 x))
        (f2-0 (-> arg1 y))
        (f1-0 (-> arg1 z))
        (f0-0 (-> arg1 w))
        )
    (set! (-> arg0 vector 0 x) f0-0)
    (set! (-> arg0 vector 0 y) f1-0)
    (set! (-> arg0 vector 0 z) (- f2-0))
    (set! (-> arg0 vector 0 w) f3-0)
    (set! (-> arg0 vector 1 x) (- f1-0))
    (set! (-> arg0 vector 1 y) f0-0)
    (set! (-> arg0 vector 1 z) f3-0)
    (set! (-> arg0 vector 1 w) f2-0)
    (set! (-> arg0 vector 2 x) f2-0)
    (set! (-> arg0 vector 2 y) (- f3-0))
    (set! (-> arg0 vector 2 z) f0-0)
    (set! (-> arg0 vector 2 w) f1-0)
    (set! (-> arg0 vector 3 x) (- f3-0))
    (set! (-> arg0 vector 3 y) (- f2-0))
    (set! (-> arg0 vector 3 z) (- f1-0))
    (set! (-> arg0 vector 3 w) f0-0)
    )
  arg0
  )

;; definition for function quaternion-left-mult-matrix!
(defun quaternion-left-mult-matrix! ((arg0 matrix) (arg1 quaternion))
  (let ((f2-0 (-> arg1 x))
        (f1-0 (-> arg1 y))
        (f0-0 (-> arg1 z))
        )
    (let ((f3-0 (-> arg1 w)))
      (set! (-> arg0 vector 0 x) f2-0)
      (set! (-> arg0 vector 0 y) f3-0)
      (set! (-> arg0 vector 0 z) (- f0-0))
      (set! (-> arg0 vector 0 w) f1-0)
      (set! (-> arg0 vector 1 x) f1-0)
      (set! (-> arg0 vector 1 y) f0-0)
      (set! (-> arg0 vector 1 z) f3-0)
      (set! (-> arg0 vector 1 w) (- f3-0))
      (set! (-> arg0 vector 2 x) f0-0)
      (set! (-> arg0 vector 2 y) (- f1-0))
      (set! (-> arg0 vector 2 z) f2-0)
      (set! (-> arg0 vector 2 w) f3-0)
      (set! (-> arg0 vector 3 x) f3-0)
      )
    (set! (-> arg0 vector 3 y) (- f2-0))
    (set! (-> arg0 vector 3 z) (- f1-0))
    (set! (-> arg0 vector 3 w) (- f0-0))
    )
  arg0
  )

;; definition for function quaternion->matrix
(defun quaternion->matrix ((arg0 matrix) (arg1 quaternion))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg1 vec quad))
    (.add.vf vf5 vf1 vf1)
    (.add.w.vf.x vf2 vf0 vf1)
    (.add.z.vf.y vf2 vf0 vf1)
    (.sub.y.vf.z vf2 vf0 vf1)
    (.sub.w.vf.w vf2 vf0 vf0)
    (.sub.z.vf.x vf3 vf0 vf1)
    (.add.w.vf.y vf3 vf0 vf1)
    (.add.x.vf.z vf3 vf0 vf1)
    (.sub.w.vf.w vf3 vf0 vf0)
    (.add.y.vf.x vf4 vf0 vf1)
    (.sub.x.vf.y vf4 vf0 vf1)
    (.add.w.vf.z vf4 vf0 vf1)
    (.sub.w.vf.w vf4 vf0 vf0)
    (.outer.product.a.vf acc vf5 vf2)
    (.outer.product.b.vf vf2 vf2 vf5 acc)
    (.outer.product.a.vf acc vf5 vf3)
    (.outer.product.b.vf vf3 vf3 vf5 acc)
    (.outer.product.a.vf acc vf5 vf4)
    (.outer.product.b.vf vf4 vf4 vf5 acc)
    (.add.w.vf.x vf2 vf2 vf0)
    (.add.w.vf.y vf3 vf3 vf0)
    (.add.w.vf.z vf4 vf4 vf0)
    (.svf (&-> arg0 vector 3 quad) vf0)
    (.svf (&-> arg0 vector 0 quad) vf2)
    (.svf (&-> arg0 vector 1 quad) vf3)
    (.svf (&-> arg0 vector 2 quad) vf4)
    arg0
    )
  )

;; definition for function matrix->quaternion
(defun matrix->quaternion ((arg0 quaternion) (arg1 matrix))
  (let ((f0-2 (+ (-> arg1 vector 0 x) (-> arg1 vector 1 y) (-> arg1 vector 2 z))))
    (cond
      ((< 0.0 f0-2)
       (let ((f0-4 (sqrtf (+ 1.0 f0-2))))
         (set! (-> arg0 w) (/ f0-4 2))
         (let ((f0-5 (/ 0.5 f0-4)))
           (set! (-> arg0 x) (* f0-5 (- (-> arg1 vector 1 z) (-> arg1 vector 2 y))))
           (set! (-> arg0 y) (* f0-5 (- (-> arg1 vector 2 x) (-> arg1 vector 0 z))))
           (set! (-> arg0 z) (* f0-5 (- (-> arg1 vector 0 y) (-> arg1 vector 1 x))))
           )
         )
       )
      (else
        (let ((a2-0 0)
              (a3-0 1)
              (v1-1 2)
              )
          (when (< (-> arg1 vector 0 x) (-> arg1 vector 1 y))
            (set! a2-0 1)
            (set! a3-0 2)
            (set! v1-1 0)
            )
          (when (< (-> (the-as (pointer float) (+ (+ (* a2-0 4) (* a2-0 16)) (the-as int arg1)))) (-> arg1 vector 2 z))
            (set! a2-0 2)
            (set! a3-0 0)
            (set! v1-1 1)
            )
          (let ((f0-12
                  (sqrtf
                    (+ (- 1.0
                          (+ (-> (the-as (pointer float) (+ (+ (* a3-0 4) (* a3-0 16)) (the-as int arg1))))
                             (-> (the-as (pointer float) (+ (+ (* v1-1 4) (* v1-1 16)) (the-as int arg1))))
                             )
                          )
                       (-> (the-as (pointer float) (+ (+ (* a2-0 4) (* a2-0 16)) (the-as int arg1))))
                       )
                    )
                  )
                )
            (set! (-> arg0 data a2-0) (/ f0-12 2))
            (if (!= f0-12 0.0)
                (set! f0-12 (/ 0.5 f0-12))
                )
            (set! (-> arg0 w)
                  (* (- (-> (the-as (pointer float) (+ (+ (* v1-1 4) (* a3-0 16)) (the-as int arg1))))
                        (-> (the-as (pointer float) (+ (+ (* a3-0 4) (* v1-1 16)) (the-as int arg1))))
                        )
                     f0-12
                     )
                  )
            (set! (-> arg0 data a3-0)
                  (* (+ (-> (the-as (pointer float) (+ (+ (* a3-0 4) (* a2-0 16)) (the-as int arg1))))
                        (-> (the-as (pointer float) (+ (+ (* a2-0 4) (* a3-0 16)) (the-as int arg1))))
                        )
                     f0-12
                     )
                  )
            (set! (-> arg0 data v1-1)
                  (* (+ (-> (the-as (pointer float) (+ (+ (* v1-1 4) (* a2-0 16)) (the-as int arg1))))
                        (-> (the-as (pointer float) (+ (+ (* a2-0 4) (* v1-1 16)) (the-as int arg1))))
                        )
                     f0-12
                     )
                  )
            )
          )
        )
      )
    )
  arg0
  )

;; definition for function matrix-with-scale->quaternion
;; INFO: Used lq/sq
(defun matrix-with-scale->quaternion ((arg0 quaternion) (arg1 matrix))
  (local-vars (a1-4 float))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         )
    (let ((v1-0 (new-stack-matrix0)))
      (let* ((f0-1 (vector-dot (-> arg1 vector 0) (-> arg1 vector 0)))
             (f1-1 (vector-dot (-> arg1 vector 1) (-> arg1 vector 1)))
             (f2-1 (vector-dot (-> arg1 vector 2) (-> arg1 vector 2)))
             (f0-3 (/ 1.0 (sqrtf f0-1)))
             (f1-3 (/ 1.0 (sqrtf f1-1)))
             (f2-3 (/ 1.0 (sqrtf f2-1)))
             )
        (.lvf vf1 (&-> arg1 vector 0 quad))
        (.lvf vf2 (&-> arg1 vector 1 quad))
        (.lvf vf3 (&-> arg1 vector 2 quad))
        (.lvf vf4 (&-> arg1 vector 3 quad))
        (let ((a1-1 f0-3))
          (.mov vf5 a1-1)
          )
        (let ((a1-2 f1-3))
          (.mov vf6 a1-2)
          )
        (let ((a1-3 f2-3))
          (.mov vf7 a1-3)
          )
        )
      (.mul.x.vf vf1 vf1 vf5)
      (.mul.x.vf vf2 vf2 vf6)
      (.mul.x.vf vf3 vf3 vf7)
      (.svf (&-> v1-0 vector 0 quad) vf1)
      (.svf (&-> v1-0 vector 1 quad) vf2)
      (.svf (&-> v1-0 vector 2 quad) vf3)
      (.svf (&-> v1-0 vector 3 quad) vf4)
      (.mov a1-4 vf4)
      (matrix->quaternion arg0 v1-0)
      )
    )
  )

;; definition for function quaternion-vector-len
(defun quaternion-vector-len ((arg0 quaternion))
  (sqrtf (- 1.0 (square (-> arg0 w))))
  )

;; definition for function quaternion-log!
(defun quaternion-log! ((arg0 quaternion) (arg1 quaternion))
  (cond
    ((= (-> arg1 w) 0.0)
     (set! (-> arg0 x) (* 1.5707963 (-> arg1 x)))
     (set! (-> arg0 y) (* 1.5707963 (-> arg1 y)))
     (set! (-> arg0 z) (* 1.5707963 (-> arg1 z)))
     )
    (else
      (let* ((f30-0 (quaternion-vector-len arg1))
             (f0-9 (/ (atan2-rad (-> arg1 w) f30-0) f30-0))
             )
        (set! (-> arg0 x) (* (-> arg1 x) f0-9))
        (set! (-> arg0 y) (* (-> arg1 y) f0-9))
        (set! (-> arg0 z) (* (-> arg1 z) f0-9))
        )
      )
    )
  arg0
  )

;; definition for function quaternion-exp!
(defun quaternion-exp! ((arg0 quaternion) (arg1 quaternion))
  (let ((f30-0 (vector-length (-> arg1 vec))))
    (cond
      ((= f30-0 0.0)
       (set! (-> arg0 x) 0.0)
       (set! (-> arg0 y) 0.0)
       (set! (-> arg0 z) 0.0)
       (set! (-> arg0 w) 1.0)
       )
      (else
        (let ((s5-0 (new 'stack-no-clear 'vector)))
          (sincos-rad! (&-> s5-0 x) f30-0)
          (let ((f0-6 (/ (-> s5-0 x) f30-0)))
            (set! (-> arg0 x) (* (-> arg1 x) f0-6))
            (set! (-> arg0 y) (* (-> arg1 y) f0-6))
            (set! (-> arg0 z) (* (-> arg1 z) f0-6))
            )
          (set! (-> arg0 w) (-> s5-0 y))
          )
        )
      )
    )
  arg0
  )

;; definition for function quaternion-slerp!
(defun quaternion-slerp! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float))
  (local-vars (v1-7 float))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         )
    (let ((f0-0 (quaternion-dot arg1 arg2))
          (f30-0 1.0)
          )
      (when (< f0-0 0.0)
        (set! f0-0 (- f0-0))
        (set! f30-0 -1.0)
        )
      (cond
        ((< (- 1.0 f0-0) 0.0001)
         (let ((v1-2 (- 1.0 arg3)))
           (.mov vf1 v1-2)
           )
         (let ((v1-3 (* arg3 f30-0)))
           (.mov vf2 v1-3)
           )
         (.lvf vf3 (&-> arg1 vec quad))
         (.lvf vf4 (&-> arg2 vec quad))
         (.mul.x.vf acc vf3 vf1)
         (.add.mul.x.vf vf3 vf4 vf2 acc)
         (.svf (&-> arg0 vec quad) vf3)
         (quaternion-normalize! arg0)
         )
        (else
          (let* ((f1-6 (sqrtf (- 1.0 (square f0-0))))
                 (f0-6 (/ (- f1-6 f0-0) (+ f1-6 f0-0)))
                 (f28-0 (/ 1.0 f1-6))
                 )
            (let ((f0-7 (atan-series-rad f0-6))
                  (s2-0 (new 'stack-no-clear 'vector))
                  )
              (set! (-> s2-0 x) (* (- 1.0 arg3) f0-7))
              (set! (-> s2-0 y) (* arg3 f0-7 f30-0))
              (vector-sin-rad! s2-0 s2-0)
              (.lvf vf1 (&-> s2-0 quad))
              )
            (let ((v1-6 f28-0))
              (.mov vf2 v1-6)
              )
            )
          (.mul.x.vf vf1 vf1 vf2)
          (.lvf vf3 (&-> arg1 vec quad))
          (.lvf vf4 (&-> arg2 vec quad))
          (.mul.x.vf acc vf3 vf1)
          (.add.mul.y.vf vf3 vf4 vf1 acc)
          (.svf (&-> arg0 vec quad) vf3)
          (.mov v1-7 vf3)
          )
        )
      )
    arg0
    )
  )

;; definition for function quaternion-pseudo-slerp!
(defun quaternion-pseudo-slerp! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         )
    (let ((f1-0 (quaternion-dot arg1 arg2))
          (f0-0 1.0)
          )
      (when (< f1-0 0.0)
        (- f1-0)
        (set! f0-0 -1.0)
        )
      (let ((v1-2 (- 1.0 arg3)))
        (.mov vf1 v1-2)
        )
      (let ((v1-3 (* arg3 f0-0)))
        (.mov vf2 v1-3)
        )
      )
    (.lvf vf3 (&-> arg1 vec quad))
    (.lvf vf4 (&-> arg2 vec quad))
    (.mul.x.vf acc vf3 vf1)
    (.add.mul.x.vf vf3 vf4 vf2 acc)
    (.svf (&-> arg0 vec quad) vf3)
    (quaternion-normalize! arg0)
    arg0
    )
  )

;; definition for function quaternion-zxy!
(defun quaternion-zxy! ((arg0 quaternion) (arg1 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)
         (vf7 :class vf)
         )
    (init-vf0-vector)
    (let ((s4-0 (new 'stack-no-clear 'vector))
          (gp-0 (new 'stack-no-clear 'vector))
          (s5-0 (new 'stack-no-clear 'vector))
          )
      (vector-rad<-vector-deg/2! s4-0 arg1)
      (vector-sincos-rad! gp-0 s5-0 s4-0)
      (.lvf vf1 (&-> gp-0 quad))
      (.lvf vf2 (&-> s5-0 quad))
      )
    (.mul.x.vf.w vf4 vf0 vf1)
    (.add.vf.xyz vf4 vf0 vf2)
    (.sub.vf.yz vf4 vf0 vf4)
    (.add.vf.xyz vf3 vf0 vf1)
    (.mul.x.vf.w vf3 vf0 vf2)
    (.outer.product.a.vf acc vf1 vf1)
    (.outer.product.b.vf vf6 vf0 vf0 acc)
    (.outer.product.a.vf acc vf2 vf2)
    (.outer.product.b.vf vf5 vf0 vf0 acc)
    (.mul.x.vf.w vf6 vf0 vf6)
    (.mul.x.vf.w vf5 vf0 vf5)
    (.mul.vf acc vf6 vf4)
    (.add.mul.vf vf7 vf5 vf3 acc)
    (.svf (&-> arg0 vec quad) vf7)
    arg0
    )
  )

;; definition for function vector-x-quaternion!
;; INFO: Used lq/sq
(defun vector-x-quaternion! ((arg0 vector) (arg1 quaternion))
  (let ((s5-0 (new-stack-matrix0)))
    (quaternion->matrix s5-0 arg1)
    (set! (-> arg0 quad) (-> (the-as (pointer uint128) (-> s5-0 vector)) 0))
    )
  arg0
  )

;; definition for function vector-y-quaternion!
;; INFO: Used lq/sq
(defun vector-y-quaternion! ((arg0 vector) (arg1 quaternion))
  (let ((s5-0 (new-stack-matrix0)))
    (quaternion->matrix s5-0 arg1)
    (set! (-> arg0 quad) (-> (the-as (pointer uint128) (-> s5-0 vector 1)) 0))
    )
  arg0
  )

;; definition for function vector-z-quaternion!
;; INFO: Used lq/sq
(defun vector-z-quaternion! ((arg0 vector) (arg1 quaternion))
  (let ((s5-0 (new-stack-matrix0)))
    (quaternion->matrix s5-0 arg1)
    (set! (-> arg0 quad) (-> (the-as (pointer uint128) (-> s5-0 vector 2)) 0))
    )
  arg0
  )

;; definition for function quaternion-y-angle
(defun quaternion-y-angle ((arg0 quaternion))
  (let ((v1-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) arg0)))
    (atan (-> v1-1 x) (-> v1-1 z))
    )
  )

;; definition for function quaternion-vector-y-angle
(defun quaternion-vector-y-angle ((arg0 quaternion) (arg1 vector))
  (let ((f30-0 (quaternion-y-angle arg0))
        (f0-2 (atan (-> arg1 x) (-> arg1 z)))
        )
    (deg-diff f30-0 f0-2)
    )
  )

;; definition for function quaternion-rotate-local-x!
;; INFO: Used lq/sq
(defun quaternion-rotate-local-x! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((a2-1 (quaternion-vector-angle! (new-stack-quaternion0) (new 'static 'vector :x 1.0 :w 1.0) arg2)))
    (quaternion-normalize! (quaternion*! arg0 arg1 a2-1))
    )
  )

;; definition for function quaternion-rotate-local-y!
;; INFO: Used lq/sq
(defun quaternion-rotate-local-y! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((a2-1 (quaternion-vector-angle! (new-stack-quaternion0) (new 'static 'vector :y 1.0 :w 1.0) arg2)))
    (quaternion-normalize! (quaternion*! arg0 arg1 a2-1))
    )
  )

;; definition for function quaternion-rotate-local-z!
;; INFO: Used lq/sq
(defun quaternion-rotate-local-z! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((a2-1 (quaternion-vector-angle! (new-stack-quaternion0) (new 'static 'vector :z 1.0 :w 1.0) arg2)))
    (quaternion-normalize! (quaternion*! arg0 arg1 a2-1))
    )
  )

;; definition for function quaternion-rotate-y!
;; INFO: Used lq/sq
(defun quaternion-rotate-y! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((a1-2 (quaternion-vector-angle! (new-stack-quaternion0) (new 'static 'vector :y 1.0 :w 1.0) arg2)))
    (quaternion-normalize! (quaternion*! arg0 a1-2 arg1))
    )
  )

;; definition for function quaternion-rotate-x!
;; INFO: Used lq/sq
(defun quaternion-rotate-x! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((a1-3 (quaternion-vector-angle! (new-stack-quaternion0) (vector-x-quaternion! (new-stack-vector0) arg1) arg2))
        )
    (quaternion-normalize! (quaternion*! arg0 a1-3 arg1))
    )
  )

;; definition for function quaternion-rotate-z!
;; INFO: Used lq/sq
(defun quaternion-rotate-z! ((arg0 quaternion) (arg1 quaternion) (arg2 float))
  (let ((a1-3 (quaternion-vector-angle! (new-stack-quaternion0) (vector-z-quaternion! (new-stack-vector0) arg1) arg2))
        )
    (quaternion-normalize! (quaternion*! arg0 a1-3 arg1))
    )
  )

;; definition for function quaternion-delta-y
(defun quaternion-delta-y ((arg0 quaternion) (arg1 quaternion))
  (acos (vector-dot
          (vector-z-quaternion! (new 'stack-no-clear 'vector) arg0)
          (vector-z-quaternion! (new 'stack-no-clear 'vector) arg1)
          )
        )
  )

;; definition for function quaternion-rotate-y-to-vector!
(defun quaternion-rotate-y-to-vector! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float))
  (let ((s5-0 (new 'stack-no-clear 'quaternion)))
    (let ((t9-0 vector-xz-normalize!)
          (a0-1 (new 'stack-no-clear 'vector))
          )
      (set! (-> a0-1 x) (-> arg2 x))
      (set! (-> a0-1 y) 0.0)
      (set! (-> a0-1 z) (-> arg2 z))
      (set! (-> a0-1 w) 1.0)
      (let ((s0-0 (t9-0 a0-1 1.0)))
        (quaternion-from-two-vectors-max-angle!
          s5-0
          (vector-z-quaternion! (-> (new 'stack-no-clear 'quaternion) vec) arg1)
          s0-0
          arg3
          )
        )
      )
    (quaternion-normalize! (quaternion*! arg0 s5-0 arg1))
    )
  )

;; definition for function vector-rotate-y!
(defun vector-rotate-y! ((arg0 vector) (arg1 vector) (arg2 float))
  (let ((a1-2 (quaternion-vector-angle! (new 'stack-no-clear 'quaternion) (new 'static 'vector :y 1.0 :w 1.0) arg2))
        (s4-0 (new 'stack-no-clear 'matrix))
        )
    (quaternion->matrix s4-0 a1-2)
    (vector-matrix*! arg0 arg1 s4-0)
    )
  )

;; definition for function vector-y-angle
(defun vector-y-angle ((arg0 vector))
  (atan (-> arg0 x) (-> arg0 z))
  )

;; definition for function vector-x-angle
(defun vector-x-angle ((arg0 vector))
  (atan (-> arg0 y) (vector-xz-length arg0))
  )

;; definition for function quaterion<-rotate-y-vector
(defun quaterion<-rotate-y-vector ((arg0 quaternion) (arg1 vector))
  (quaternion-vector-angle! arg0 (new 'static 'vector :y 1.0 :w 1.0) (vector-y-angle arg1))
  )

;; definition (debug) for function quaternion-validate
;; INFO: Return type mismatch int vs none.
(defun-debug quaternion-validate ((arg0 quaternion))
  (with-pp
    (let ((f0-0 (quaternion-norm arg0)))
      (when (or (< 1.01 f0-0) (< f0-0 0.99))
        (format #t "WARNING: bad quaternion (magnitude ~F) process is " f0-0)
        (if (and pp (type-type? (-> pp type) process-tree))
            (format #t "~A~%" (-> pp name))
            (format #t "#f~%")
            )
        )
      )
    0
    (none)
    )
  )

;; definition for function quaternion-xz-angle
(defun quaternion-xz-angle ((arg0 quaternion))
  (let ((gp-0 (new 'stack-no-clear 'matrix))
        (s5-0 (new 'stack-no-clear 'vector))
        )
    (quaternion->matrix gp-0 arg0)
    (set-vector! s5-0 0.0 0.0 1.0 1.0)
    (vector-matrix*! s5-0 s5-0 gp-0)
    (vector-y-angle s5-0)
    )
  )