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

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

;; ---- TOP LEVEL COMMENT TODO ----

;; TODO - rand-vu-sphere-point! (fails to decomp)

;; (defun sphere<-vector+r! ((arg0 sphere) (arg1 vector) (arg2 float))
;;   (local-vars (v1-0 int))
;;   (TODO.LQ v1-0 arg1)
;;   (TODO.SQ v1-0 arg0)
;;   (set! (-> arg0 data 3) arg2)
;;   arg0
;;   )

;; (defun sphere<-vector! ((arg0 sphere) (arg1 vector))
;;   (local-vars (v1-0 int) (f0-0 float))
;;   (set! f0-0 (-> arg0 data 3))
;;   (TODO.LQ v1-0 arg1)
;;   (TODO.SQ v1-0 arg0)
;;   (set! (-> arg0 data 3) f0-0)
;;   arg0
;;   )

;; (defun spheres-overlap? ((arg0 vector) (arg1 vector))
;;   "TODO"
;;   (local-vars (v1-0 int)
;;               (a0-1 int))
;;   (rlet ((vf0 :class vf)
;;          (vf1 :class vf)
;;          (vf2 :class vf)
;;          (vf3 :class vf)
;;          (vf4 :class vf))
;;     (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
;;     (.lvf vf1 arg0)
;;     (.lvf vf2 arg1)
;;     (.sub.vf vf3 vf1 vf2 :mask #b1110)
;;     (.mul.vf vf3 vf3 vf3 :mask #b1110)
;;     (.add.w.vf vf4 vf1 vf2 :mask #b1)
;;     (.mul.w.vf vf4 vf4 vf4 :mask #b1)
;;     (.add.y.vf vf3 vf3 vf3 :mask #b1000)
;;     (.add.z.vf vf3 vf3 vf3 :mask #b1000)
;;     (.add.w.vf vf4 vf0 vf4 :mask #b1000)
;;     (.mov a0-1 vf4)
;;     (.mov v1-0 vf3)
;;     (>= (the-as float (gpr->fpr a0-1))
;;         (the-as float (gpr->fpr v1-0)))))

(defun vector3s-! ((arg0 vector) (arg1 vector) (arg2 vector))
  "Subtract 2 vectors3: c = (a - b)"
  (set! (-> arg0 data 0) (- (-> arg1 data 0) (-> arg2 data 0)))
  (set! (-> arg0 data 1) (- (-> arg1 data 1) (-> arg2 data 1)))
  (set! (-> arg0 data 2) (- (-> arg1 data 2) (-> arg2 data 2)))
  arg0)

(defun vector3s*float! ((arg0 vector) (arg1 vector) (arg2 float))
  "Multiply 2 vectors3 by some float"
  (set! (-> arg0 data 0) (* (-> arg1 data 0) arg2))
  (set! (-> arg0 data 1) (* (-> arg1 data 1) arg2))
  (set! (-> arg0 data 2) (* (-> arg1 data 2) arg2))
  arg0)

(defun vector3s+! ((arg0 vector) (arg1 vector) (arg2 vector))
  "Add 2 vectors3"
  (set! (-> arg0 data 0) (+ (-> arg1 data 0) (-> arg2 data 0)))
  (set! (-> arg0 data 1) (+ (-> arg1 data 1) (-> arg2 data 1)))
  (set! (-> arg0 data 2) (+ (-> arg1 data 2) (-> arg2 data 2)))
  arg0)

(defun vector3s-copy! ((arg0 vector) (arg1 vector))
  "Copy a vector3s"
  (set! (-> arg0 data 0) (-> arg1 data 0))
  (set! (-> arg0 data 1) (-> arg1 data 1))
  (set! (-> arg0 data 2) (-> arg1 data 2))
  arg0)

;; TODO - vector-deg-lerp-clamp! (fails to decomp)
;; - WARN: Type Propagation failed: Function vector-deg-lerp-clamp! has unknown type

;; (defun vector-deg-diff ((arg0 vector) (arg1 vector) (arg2 vector))
;;   "TODO"
;;   (local-vars (v0-0 int)
;;               (v1-0 int)
;;               (v1-1 int)
;;               (v1-2 int)
;;               (v1-3 int)
;;               (a1-1 int)
;;               (a1-2 int))
;;   (rlet ((vf1 :class vf)
;;          (vf2 :class vf))
;;     (.lvf vf1 arg1)
;;     (.lvf vf2 arg2)
;;     (.ftoi.vf vf1 vf1)
;;     (.ftoi.vf vf2 vf2)
;;     (.mov a1-1 vf1)
;;     (.mov v1-0 vf2)
;;     (TODO.PSLLW a1-2 a1-1 16)
;;     (TODO.PSLLW v1-1 v1-0 16)
;;     (TODO.PSUBW v1-2 a1-2 v1-1)
;;     (TODO.PSRAW v1-3 v1-2 16)
;;     (.mov vf1 v1-3)
;;     (.itof.vf vf1 vf1)
;;     (.svf arg0 vf1)
;;     (.mov v0-0 vf1)
;;     (the-as vector v0-0)))

;; (defun vector-degmod ((arg0 vector) (arg1 vector))
;;   "TODO"
;;   (local-vars (v1-0 int)
;;               (v1-1 int)
;;               (v1-2 int))
;;   (rlet ((vf1 :class vf))
;;     (.lvf vf1 arg1)
;;     (.ftoi.vf vf1 vf1)
;;     (.mov v1-0 vf1)
;;     (TODO.PSLLW v1-1 v1-0 16)
;;     (TODO.PSRAW v1-2 v1-1 16)
;;     (.mov vf1 v1-2)
;;     (.itof.vf vf1 vf1)
;;     (.svf arg0 vf1)
;;     arg0))

;; (defun vector-degf ((arg0 vector) (arg1 vector))
;;   "TODO"
;;   (local-vars (v1-0 int)
;;               (v1-1 int))
;;   (rlet ((vf1 :class vf))
;;     (TODO.LQ v1-0 arg1)
;;     (TODO.PSRAW v1-1 v1-0 16)
;;     (.mov vf1 v1-1)
;;     (.itof.vf vf1 vf1)
;;     (.svf arg0 vf1)
;;     arg0))

;; (defun vector-degi ((arg0 vector) (arg1 vector))
;;   "TODO"
;;   (local-vars (v1-0 int)
;;               (v1-1 int))
;;   (rlet ((vf1 :class vf))
;;     (.lvf vf1 arg1)
;;     (.ftoi.vf vf1 vf1)
;;     (.mov v1-0 vf1)
;;     (TODO.PSLLW v1-1 v1-0 16)
;;     (TODO.SQ v1-1 arg0)
;;     arg0))

;; (defun vector4-lerp-clamp! ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float))
;;   "TODO"
;;   (local-vars (v1-0 int)
;;               (v1-1 int)
;;               (v1-2 vector)
;;               (a1-1 float)
;;               (f0-2 float))
;;   (rlet ((vf1 :class vf)
;;          (vf2 :class vf)
;;          (vf3 :class vf)
;;          (vf4 :class vf))
;;     (cond
;;       ((>= 0.000000 arg3)
;;         (TODO.LQ v1-0 arg1)
;;         (TODO.SQ v1-0 arg0))
;;       ((>= arg3 (l.f POSITIVE_ONE))
;;         (TODO.LQ v1-1 arg2)
;;         (TODO.SQ v1-1 arg0))
;;       (else
;;         (set! v1-2 arg0)
;;         (set! f0-2 arg3)
;;         (.lvf vf1 arg1)
;;         (.lvf vf2 arg2)
;;         (set! a1-1 f0-2)
;;         (.mov vf4 a1-1)
;;         (.sub.vf vf2 vf2 vf1)
;;         (.mul.x.vf vf2 vf2 vf4)
;;         (.add.vf vf3 vf1 vf2)
;;         (.svf v1-2 vf3)))
;;     arg0))

(defun vector4-lerp! ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (a2-0 none)
              (a3-0 none))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf))
    (.lvf vf1 arg1)
    (.lvf vf2 a2-0)
    (.mov vf4 a3-0)
    (.sub.vf vf2 vf2 vf1)
    (.mul.x.vf vf2 vf2 vf4)
    (.add.vf vf3 vf1 vf2)
    (.svf arg0 vf3)
    arg0))

;; (defun vector-lerp-clamp! ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float))
;;   "TODO"
;;   (local-vars (v1-0 int)
;;               (v1-1 int)
;;               (v1-2 vector)
;;               (a1-1 float)
;;               (f0-2 float))
;;   (rlet ((vf0 :class vf)
;;          (vf1 :class vf)
;;          (vf2 :class vf)
;;          (vf3 :class vf)
;;          (vf4 :class vf))
;;     (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
;;     (cond
;;       ((>= 0.000000 arg3)
;;         (TODO.LQ v1-0 arg1)
;;         (TODO.SQ v1-0 arg0))
;;       ((>= arg3 (l.f POSITIVE_ONE))
;;         (TODO.LQ v1-1 arg2)
;;         (TODO.SQ v1-1 arg0))
;;       (else
;;         (set! v1-2 arg0)
;;         (set! f0-2 arg3)
;;         (.lvf vf1 arg1)
;;         (.lvf vf2 arg2)
;;         (set! a1-1 f0-2)
;;         (.mov vf4 a1-1)
;;         (.add.x.vf vf3 vf0 vf0 :mask #b1)
;;         (.sub.vf vf2 vf2 vf1)
;;         (.mul.x.vf vf2 vf2 vf4)
;;         (.add.vf vf3 vf1 vf2 :mask #b1110)
;;         (.svf v1-2 vf3)))
;;     arg0))

(defun vector-lerp! ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (a2-0 none)
              (a3-0 none))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf1 arg1)
    (.lvf vf2 a2-0)
    (.mov vf4 a3-0)
    (.add.x.vf vf3 vf0 vf0 :mask #b1)
    (.sub.vf vf2 vf2 vf1)
    (.mul.x.vf vf2 vf2 vf4)
    (.add.vf vf3 vf1 vf2 :mask #b1110)
    (.svf arg0 vf3)
    arg0))

(defun rot-zyx-from-vector! ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (v1-0 float)
              (f0-1 float)
              (f0-5 float)
              (f0-6 float)
              (f26-0 float)
              (f28-0 float)
              (f30-0 float))
  (set! f28-0 (-> arg1 data 2))
  (set! f30-0 (- (-> arg1 data 1)))
  (set! f0-1 (atan f30-0 f28-0))
  (set! (-> arg0 data 0) f0-1)
  (set! f26-0 (- f0-1))
  (set! f0-5 (- (* f28-0 (cos f26-0)) (* f30-0 (sin f26-0))))
  (set! f0-6 (atan (-> arg1 data 0) f0-5))
  (set! (-> arg0 data 1) f0-6)
  (set! v1-0 f0-6)
  (set! (-> arg0 data 2) 0.000000)
  arg0)

(defun rot-zxy-from-vector! ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (v1-0 float)
              (f0-0 float)
              (f0-4 float)
              (f0-5 float)
              (f26-0 float)
              (f28-0 float)
              (f30-0 float))
  (set! f28-0 (-> arg1 data 2))
  (set! f30-0 (-> arg1 data 0))
  (set! f0-0 (atan f30-0 f28-0))
  (set! (-> arg0 data 1) f0-0)
  (set! f26-0 (- f0-0))
  (set! f0-4 (- (* f28-0 (cos f26-0)) (* f30-0 (sin f26-0))))
  (set! f0-5 (atan (- (-> arg1 data 1)) f0-4))
  (set! (-> arg0 data 0) f0-5)
  (set! v1-0 f0-5)
  (set! (-> arg0 data 2) 0.000000)
  arg0)

(defun vector-cvt.s.w! ((arg0 vector) (arg1 vector))
  "TODO"
  (rlet ((vf1 :class vf))
    (.lvf vf1 arg1)
    (.itof.vf vf1 vf1)
    (.svf arg0 vf1)
    arg0))

(defun vector-cvt.w.s! ((arg0 vector) (arg1 vector))
  "TODO"
  (rlet ((vf1 :class vf))
   (.lvf vf1 arg1)
   (.ftoi.vf vf1 vf1)
   (.svf arg0 vf1)
   arg0
   )
  )

(defun rotate-y<-vector+vector ((arg0 vector) (arg1 vector))
  "TODO"
  (atan
    (- (-> arg1 data 0) (-> arg0 data 0))
    (- (-> arg1 data 2) (-> arg0 data 2))))

;; (defun vector-rotate-around-y! ((arg0 vector) (arg1 vector) (arg2 float))
;;   "TODO"
;;   (local-vars (v1-0 int) (f0-0 float) (f26-0 float) (f28-0 float) (f30-0 float))
;;   (set! f26-0 (-> arg1 data 2))
;;   (set! f30-0 (-> arg1 data 0))
;;   (set! f28-0 (cos arg2))
;;   (set! f0-0 (sin arg2))
;;   (TODO.lq v1-0 arg1)
;;   (TODO.sq v1-0 arg0)
;;   (set! (-> arg0 data 2) (- (* f26-0 f28-0) (* f30-0 f0-0)))
;;   (set! (-> arg0 data 0) (+ (* f26-0 f0-0) (* f30-0 f28-0)))
;;   arg0)

(defun vector-xz-length ((arg0 vector))
  "TODO"
  (sqrtf
    (+ (* (-> arg0 data 0) (-> arg0 data 0))
       (* (-> arg0 data 2) (-> arg0 data 2)))))

(defun vector-xz-length-max! ((arg0 vector) (arg1 float))
  "TODO"
  (local-vars (v1-4 float)
              (f0-0 float)
              (f0-1 float))
  (set! f0-0 (vector-xz-length arg0))
  (when
    (not (or (= f0-0 0.000000)
             (< f0-0 arg1)))
    (set! f0-0 (/ f0-0 arg1))
    (when (!= f0-0 0.000000)
      (set! (-> arg0 data 0) (/ (-> arg0 data 0) f0-0))
      (set! f0-1 (/ (-> arg0 data 2) f0-0))
      (set! (-> arg0 data 2) f0-1)
      (set! v1-4 f0-1)))
  arg0)

(defun vector-length ((arg0 vector))
  "TODO"
  (local-vars (v0-0 float))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf1 arg0)
    (.mul.vf vf1 vf1 vf1)
    (.mul.x.vf acc vf0 vf1 :mask #b1)
    (.add.mul.y.vf acc vf0 vf1 acc :mask #b1)
    (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1)
    (.sqrt.vf Q vf1 :ftf #b11)
    (.add.w.vf vf1 vf0 vf0 :mask #b1000)
    (.wait.vf)
    (.mul.vf vf1 vf1 Q :mask #b1000)
    (.nop.vf)
    (.nop.vf)
    (.mov v0-0 vf1)
    (the-as float v0-0)))

(defun vector-length-max! ((arg0 vector) (arg1 float))
  "TODO"
  (local-vars (v1-4 float)
              (f0-0 float)
              (f0-1 float))
  (set! f0-0 (vector-length arg0))
  (when
    (not (or (= f0-0 0.000000)
             (< f0-0 arg1)))
    (set! f0-0 (/ f0-0 arg1))
    (when (!= f0-0 0.000000)
      (set! (-> arg0 data 0) (/ (-> arg0 data 0) f0-0))
      (set! (-> arg0 data 1) (/ (-> arg0 data 1) f0-0))
      (set! f0-1 (/ (-> arg0 data 2) f0-0))
      (set! (-> arg0 data 2) f0-1)
      (set! v1-4 f0-1)))
  arg0)

(defun vector-xz-normalize! ((arg0 vector) (arg1 float))
  "TODO"
  (local-vars (v1-1 float)
              (v1-2 float)
              (f0-0 float)
              (f0-5 float))
  (set! f0-0 (vector-xz-length arg0))
  (when (!= f0-0 0.000000)
    (set! v1-1 (/ arg1 f0-0))
    (set! (-> arg0 data 0) (* (-> arg0 data 0) v1-1))
    (set! f0-5 (* (-> arg0 data 2) v1-1))
    (set! (-> arg0 data 2) f0-5)
    (set! v1-2 f0-5))
  arg0)

;; (defun vector-normalize-copy! ((arg0 vector) (arg1 vector) (arg2 float))
;;   "TODO"
;;   (local-vars (v1-0 int)
;;               (v1-1 float)
;;               (v1-2 float)
;;               (f0-0 float)
;;               (f0-7 float))
;;   (set! f0-0 (vector-length arg1))
;;   (cond
;;     ((= f0-0 0.000000)
;;       (TODO.LQ v1-0 arg1)
;;       (TODO.SQ v1-0 arg0))
;;     (else
;;       (set! v1-1 (/ arg2 f0-0))
;;       (set! (-> arg0 data 0) (* (-> arg1 data 0) v1-1))
;;       (set! (-> arg0 data 1) (* (-> arg1 data 1) v1-1))
;;       (set! f0-7 (* (-> arg1 data 2) v1-1))
;;       (set! (-> arg0 data 2) f0-7)
;;       (set! v1-2 f0-7)))
;;   (set! (-> arg0 data 3) (l.f POSITIVE_ONE))
;;   arg0)

;; (defun vector-normalize-ret-len! ((a0-0 vector) (a1-0 float))
;;   "TODO"
;;   (local-vars (v0-0 float)
;;               (v1-0 float)
;;               (v1-1 int)
;;               (f0-0 int)
;;               (f0-1 float))
;;   (rlet ((acc :class vf)
;;          (Q :class vf)
;;          (vf0 :class vf)
;;          (vf1 :class vf)
;;          (vf2 :class vf)
;;          (vf3 :class vf))
;;     (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
;;     (.lvf vf1 a0-0)
;;     (.mul.vf vf2 vf1 vf1 :mask #b1110)
;;     (set! v1-0 a1-0)
;;     (.mov vf3 v1-0)
;;     (.mul.x.vf acc vf0 vf2 :mask #b1)
;;     (.add.mul.y.vf acc vf0 vf2 acc :mask #b1)
;;     (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1)
;;     (.isqrt.vf Q vf3 vf2 :ftf #b0 :fsf #b11)
;;     (.add.w.vf vf2 vf0 vf2 :mask #b1000)
;;     (.mov v1-1 vf2)
;;     (set! f0-0 (gpr->fpr v1-1))
;;     (set! f0-1 (sqrt.s f0-0))
;;     (set! v0-0 (fpr->gpr f0-1))
;;     (.wait.vf)
;;     (.mul.vf vf1 vf1 Q :mask #b1110)
;;     (.nop.vf)
;;     (.nop.vf)
;;     (.nop.vf)
;;     (.svf a0-0 vf1)
;;     (ret-value v0-0)))

(defun vector-vector-xz-distance-squared ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (v0-0 int))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf))
    (.lvf vf2 arg0)
    (.lvf vf3 arg1)
    (.sub.vf vf1 vf3 vf2)
    (.mul.vf vf1 vf1 vf1)
    (.add.z.vf vf1 vf1 vf1 :mask #b1000)
    (.mov v0-0 vf1)
    (the-as float v0-0)))

(defun vector-vector-xz-distance ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (v0-0 int))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf2 arg0)
    (.lvf vf3 arg1)
    (.sub.vf vf1 vf3 vf2)
    (.mul.vf vf1 vf1 vf1)
    (.mul.x.vf acc vf0 vf1 :mask #b1)
    (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1)
    (.sqrt.vf Q vf1 :ftf #b11)
    (.add.w.vf vf1 vf0 vf0 :mask #b1000)
    (.wait.vf)
    (.mul.vf vf1 vf1 Q :mask #b1000)
    (.nop.vf)
    (.nop.vf)
    (.mov v0-0 vf1)
    (the-as float v0-0)))

(defun vector-vector-distance-squared ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (v0-0 int))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf))
    (.lvf vf2 arg0)
    (.lvf vf3 arg1)
    (.sub.vf vf1 vf3 vf2)
    (.mul.vf vf1 vf1 vf1)
    (.add.y.vf vf1 vf1 vf1 :mask #b1000)
    (.add.z.vf vf1 vf1 vf1 :mask #b1000)
    (.mov v0-0 vf1)
    (the-as float v0-0)))

(defun vector-vector-distance ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (v0-0 int))
  (rlet ((acc :class vf)
         (Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf2 arg0)
    (.lvf vf3 arg1)
    (.sub.vf vf1 vf3 vf2)
    (.mul.vf vf1 vf1 vf1)
    (.mul.x.vf acc vf0 vf1 :mask #b1)
    (.add.mul.y.vf acc vf0 vf1 acc :mask #b1)
    (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1)
    (.sqrt.vf Q vf1 :ftf #b11)
    (.add.w.vf vf1 vf0 vf0 :mask #b1000)
    (.wait.vf)
    (.mul.vf vf1 vf1 Q :mask #b1000)
    (.nop.vf)
    (.nop.vf)
    (.mov v0-0 vf1)
    (the-as float v0-0)))

(defun vector-xz-length-squared ((arg0 vector))
  "TODO"
  (+ (* (-> arg0 data 0) (-> arg0 data 0))
     (* (-> arg0 data 2) (-> arg0 data 2))))

(defun vector-length-squared ((arg0 vector))
  "TODO"
  (local-vars (v0-0 int))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf1 arg0)
    (.add.w.vf vf2 vf0 vf0 :mask #b1000)
    (.mul.vf vf1 vf1 vf1)
    (.mul.x.vf acc vf2 vf1 :mask #b1000)
    (.add.mul.y.vf acc vf2 vf1 acc :mask #b1000)
    (.add.mul.z.vf vf1 vf2 vf1 acc :mask #b1000)
    (.mov v0-0 vf1)
    (the-as float v0-0)))

(defun vector-from-ups! ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (at-0 int)
              (f0-0 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf1 arg1)
    (set! f0-0 (-> *display* seconds-per-frame))
    (.mov at-0 f0-0)
    (.mov vf2 at-0)
    (.mov.vf vf1 vf0 :mask #b1)
    (.mul.x.vf vf1 vf1 vf2 :mask #b1110)
    (.svf arg0 vf1)
    arg0))

(defun vector-to-ups! ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (at-0 int)
              (f0-0 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf1 arg1)
    (set! f0-0 (-> *display* frames-per-second))
    (.mov at-0 f0-0)
    (.mov vf2 at-0)
    (.mov.vf vf1 vf0 :mask #b1)
    (.mul.x.vf vf1 vf1 vf2 :mask #b1110)
    (.svf arg0 vf1)
    arg0))

(defun vector+float*! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float))
  "TODO"
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf2 arg2)
    (.lvf vf1 arg1)
    (.mov vf3 arg3)
    (.add.x.vf vf4 vf0 vf0 :mask #b1)
    (.mul.x.vf acc vf2 vf3)
    (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b1110)
    (.svf arg0 vf4)
    arg0))

(defun vector-v*float++! ((arg0 vector) (arg1 vector) (arg2 float))
  "TODO"
  (vector+float*! arg0 arg0 arg1 (* arg2 (-> *display* seconds-per-frame)))
  arg0)

(defun vector-v*float! ((arg0 vector) (arg1 float) (arg2 float))
  "TODO"
  (local-vars (v0-0 vector)
              (v1-0 float)
              (v1-1 float)
              (f0-1 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf))
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (set! v0-0 arg0)
   (set! v1-0 arg1)
   (set! f0-1 (* arg2 (-> *display* seconds-per-frame)))
   (.lvf vf1 v1-0)
   (set! v1-1 f0-1)
   (.mov vf2 v1-1)
   (.add.x.vf vf1 vf0 vf0 :mask #b1)
   (.mul.x.vf vf1 vf1 vf2 :mask #b1110)
   (.svf v0-0 vf1)
   v0-0))

(defun vector-v++! ((arg0 vector) (arg1 vector))
  "TODO"
  (vector+float*! arg0 arg0 arg1 (-> *display* seconds-per-frame))
  arg0)

(defun vector-v*float+! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float))
  "TODO"
  (vector+float*! arg0 arg1 arg2 (* arg3 (-> *display* seconds-per-frame)))
  arg0)

(defun vector-v+! ((arg0 vector) (arg1 vector) (arg2 vector))
  "TODO"
  (vector+float*! arg0 arg1 arg2 (-> *display* seconds-per-frame))
  arg0)

(defun vector-v! ((arg0 vector))
  "TODO"
  (local-vars (v1-0 vector)
              (a1-0 vector)
              (a1-1 float)
              (f0-0 float))
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (set! v1-0 arg0)
    (set! a1-0 arg0)
    (set! f0-0 (-> *display* seconds-per-frame))
    (.lvf vf1 a1-0)
    (set! a1-1 f0-0)
    (.mov vf2 a1-1)
    (.add.x.vf vf1 vf0 vf0 :mask #b1)
    (.mul.x.vf vf1 vf1 vf2 :mask #b1110)
    (.svf v1-0 vf1)
    arg0))

(defun vector-seconds! ((arg0 vector))
  "TODO"
  (set! (-> arg0 data 0) (* 300.000000 (-> arg0 data 0)))
  (set! (-> arg0 data 1) (* 300.000000 (-> arg0 data 1)))
  (set! (-> arg0 data 2) (* 300.000000 (-> arg0 data 2)))
  arg0)

(defun vector-seconds ((arg0 vector) (arg1 vector))
  "TODO"
  (set! (-> arg0 data 0) (* 300.000000 (-> arg1 data 0)))
  (set! (-> arg0 data 1) (* 300.000000 (-> arg1 data 1)))
  (set! (-> arg0 data 2) (* 300.000000 (-> arg1 data 2)))
  arg0)

(defun vector-identity! ((arg0 vector))
  "TODO"
  (set! (-> arg0 data 0) 1.000000)
  (set! (-> arg0 data 1) 1.000000)
  (set! (-> arg0 data 2) 1.000000)
  (set! (-> arg0 data 3) 1.000000)
  arg0)

(defun seek-with-smooth ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
  "TODO"
  (local-vars (v1-1 float)
              (v1-3 float)
              (f0-1 float)
              (f0-2 float)
              (f1-4 float))
  (set! f0-1 (- arg1 arg0))
  (cond
    ((>= arg4 (fabs f0-1)) arg1)
    (else
      (set! f0-2 (* f0-1 arg3))
      (set! f1-4 (- arg2))
      (cond
        ((< f0-2 f1-4)
          (set! f0-2 f1-4)
          (set! v1-1 f0-2))
        ((< arg2 f0-2)
          (set! f0-2 arg2)
          (set! v1-3 f0-2)))
      (+ f0-2 arg0))))

(defun vector-seek-3d-smooth! ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float))
  "TODO"
  (local-vars (v1-4 float)
              (v1-5 float)
              (f0-1 float)
              (f0-4 float)
              (f0-5 float)
              (f0-7 float)
              (f1-2 float)
              (f1-3 float)
              (f2-6 float)
              (f3-1 float)
              (f3-4 float)
              (f3-5 float)
              (f3-7 float))
  (set! f0-1 (- (-> arg1 data 0) (-> arg0 data 0)))
  (set! f1-2 (- (-> arg1 data 1) (-> arg0 data 1)))
  (set! f3-1 (- (-> arg1 data 2) (-> arg0 data 2)))
  (when
    (or (!= f0-1 0.000000) (!= f1-2 0.000000) (!= f3-1 0.000000))
    (set! f2-6 (* f0-1 arg3))
    (set! f1-3 (* f1-2 arg3))
    (set! f0-4 (* f3-1 arg3))
    (set! f3-4 (+ (+ (* f2-6 f2-6) (* f1-3 f1-3)) (* f0-4 f0-4)))
    (set! f3-5 (sqrtf f0-4))
    (cond
      ((>= arg2 f3-5)
        (set! (-> arg0 data 0) (+ (-> arg0 data 0) f2-6))
        (set! (-> arg0 data 1) (+ (-> arg0 data 1) f1-3))
        (set! f0-5 (+ (-> arg0 data 2) f0-4))
        (set! (-> arg0 data 2) f0-5)
        (set! v1-4 f0-5))
      (else
        (set! f3-7 (/ arg2 f3-5))
        (set! (-> arg0 data 0) (+ (-> arg0 data 0) (* f3-7 f2-6)))
        (set! (-> arg0 data 1) (+ (-> arg0 data 1) (* f3-7 f1-3)))
        (set! f0-7 (+ (-> arg0 data 2) (* f3-7 f0-4)))
        (set! (-> arg0 data 2) f0-7)
        (set! v1-5 f0-7))))
  arg0)

(defun vector-seek-2d-yz-smooth! ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float))
  "TODO"
  (local-vars (v1-3 float)
              (v1-4 float)
              (f0-1 float)
              (f0-3 float)
              (f0-4 float)
              (f0-6 float)
              (f1-5 float)
              (f2-1 float)
              (f2-3 float)
              (f2-4 float)
              (f2-6 float))
  (set! f0-1 (- (-> arg1 data 1) (-> arg0 data 1)))
  (set! f2-1 (- (-> arg1 data 2) (-> arg0 data 2)))
  (when
    (or (!= f0-1 0.000000) (!= f2-1 0.000000))
    (set! f1-5 (* f0-1 arg3))
    (set! f0-3 (* f2-1 arg3))
    (set! f2-3 (+ (* f1-5 f1-5) (* f0-3 f0-3)))
    (set! f2-4 (sqrtf f0-3))
    (cond
      ((>= arg2 f2-4)
        (set! (-> arg0 data 1) (+ (-> arg0 data 1) f1-5))
        (set! f0-4 (+ (-> arg0 data 2) f0-3))
        (set! (-> arg0 data 2) f0-4)
        (set! v1-3 f0-4))
      (else
        (set! f2-6 (/ arg2 f2-4))
        (set! (-> arg0 data 1) (+ (-> arg0 data 1) (* f2-6 f1-5)))
        (set! f0-6 (+ (-> arg0 data 2) (* f2-6 f0-3)))
        (set! (-> arg0 data 2) f0-6)
        (set! v1-4 f0-6))))
  arg0)

(defun vector-seek-2d-xz-smooth! ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float))
  "TODO"
  (local-vars (v1-3 float)
              (v1-4 float)
              (f0-1 float)
              (f0-3 float)
              (f0-4 float)
              (f0-6 float)
              (f1-5 float)
              (f2-1 float)
              (f2-3 float)
              (f2-4 float)
              (f2-6 float))
  (set! f0-1 (- (-> arg1 data 0) (-> arg0 data 0)))
  (set! f2-1 (- (-> arg1 data 2) (-> arg0 data 2)))
  (when
    (or (!= f0-1 0.000000) (!= f2-1 0.000000))
    (set! f1-5 (* f0-1 arg3))
    (set! f0-3 (* f2-1 arg3))
    (set! f2-3 (+ (* f1-5 f1-5) (* f0-3 f0-3)))
    (set! f2-4 (sqrtf f0-3))
    (cond
      ((>= arg2 f2-4)
        (set! (-> arg0 data 0) (+ (-> arg0 data 0) f1-5))
        (set! f0-4 (+ (-> arg0 data 2) f0-3))
        (set! (-> arg0 data 2) f0-4)
        (set! v1-3 f0-4))
      (else
        (set! f2-6 (/ arg2 f2-4))
        (set! (-> arg0 data 0) (+ (-> arg0 data 0) (* f2-6 f1-5)))
        (set! f0-6 (+ (-> arg0 data 2) (* f2-6 f0-3)))
        (set! (-> arg0 data 2) f0-6)
        (set! v1-4 f0-6))))
  arg0)

(defun vector-seek! ((arg0 vector) (arg1 vector) (arg2 float))
  "TODO"
  (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))
    (.mov vf4 arg2)
    (.lvf vf1 arg1)
    (.lvf vf2 arg0)
    (.add.x.vf vf1 vf0 vf0 :mask #b1)
    (.sub.x.vf vf5 vf0 vf4 :mask #b1000)
    (.sub.vf vf3 vf1 vf2 :mask #b1110)
    (.min.x.vf vf3 vf3 vf4 :mask #b1110)
    (.max.x.vf vf3 vf3 vf5 :mask #b1110)
    (.add.vf vf1 vf2 vf3 :mask #b1110)
    (.svf arg0 vf1)
    arg0))

(defun vector-delta ((arg0 vector) (arg1 vector))
  "TODO"
  (local-vars (v0-0 int))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf))
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.lvf vf1 arg0)
   (.lvf vf2 arg1)
   (.sub.vf vf1 vf2 vf1)
   (.abs.vf vf1 vf1)
   (.mul.x.vf acc vf0 vf1 :mask #b1)
   (.add.mul.y.vf acc vf0 vf1 acc :mask #b1)
   (.add.mul.z.vf vf3 vf0 vf1 acc :mask #b1)
   (.add.w.vf vf3 vf0 vf3 :mask #b1000)
   (.mov v0-0 vf3)
   (the-as float v0-0)))

;; TODO - vector= (decomp failed)

(defun vector-negate-in-place! ((arg0 vector))
  "TODO"
  (rlet ((vf0 :class vf)
         (vf1 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf1 arg0)
    (.sub.vf vf1 vf0 vf1 :mask #b1110)
    (.svf arg0 vf1)
    arg0))

(defun vector-negate! ((arg0 vector) (arg1 vector))
  "TODO"
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf4 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf1 arg1)
    (.sub.vf vf4 vf0 vf1 :mask #b1110)
    (.add.x.vf vf4 vf0 vf0 :mask #b1)
    (.svf arg0 vf4)
    arg0))

(defun vector-float/! ((arg0 vector) (arg1 vector) (arg2 float))
  "TODO"
  (rlet ((Q :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf3 :class vf)
         (vf4 :class vf))
   (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
   (.mov vf3 arg2)
   (.div.vf Q vf0 vf3 :ftf #b11 :fsf #b0)
   (.lvf vf1 arg1)
   (.add.x.vf vf4 vf0 vf0 :mask #b1)
   (.wait.vf)
   (.mul.vf vf4 vf1 Q :mask #b1110)
   (.nop.vf)
   (.nop.vf)
   (.svf arg0 vf4)
   arg0))

(defun vector--float*! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float))
  "TODO"
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf2 arg2)
    (.lvf vf1 arg1)
    (.mov vf3 arg3)
    (.add.x.vf vf4 vf0 vf0 :mask #b1)
    (.mul.w.vf acc vf1 vf0)
    (.sub.mul.x.vf vf4 vf2 vf3 acc :mask #b1110)
    (.svf arg0 vf4)
    arg0))

(defun vector-average! ((arg0 vector) (arg1 vector) (arg2 vector))
  "TODO"
  (local-vars (v1-0 int))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (set! v1-0 #x3f000000)
    (.lvf vf1 arg1)
    (.lvf vf2 arg2)
    (.mov vf3 v1-0)
    (.add.x.vf vf4 vf0 vf0 :mask #b1)
    (.mul.x.vf acc vf1 vf3)
    (.add.mul.x.vf vf4 vf2 vf3 acc :mask #b1110)
    (.svf arg0 vf4)
    arg0))

(defun vector-float*! ((arg0 vector) (arg1 vector) (arg2 float))
  "TODO"
  (rlet ((vf0 :class vf)
         (vf1 :class vf)
         (vf2 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf1 arg1)
    (.mov vf2 arg2)
    (.add.x.vf vf1 vf0 vf0 :mask #b1)
    (.mul.x.vf vf1 vf1 vf2 :mask #b1110)
    (.svf arg0 vf1)
    arg0))

(defun vector/! ((arg0 vector) (arg1 vector) (arg2 vector))
  "TODO"
  (local-vars (v1-0 float))
  (rlet ((Q :class vf)
         (vf0 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.lvf vf5 arg2)
    (.div.vf Q vf0 vf5 :ftf #b11 :fsf #b1)
    (.add.x.vf vf6 vf0 vf0 :mask #b1)
    (.lvf vf4 arg1)
    (set! v1-0 (/ (-> arg1 data 0) (-> arg2 data 0)))
    (.wait.vf)
    (.mul.vf vf6 vf4 Q :mask #b100)
    (.nop.vf)
    (.nop.vf)
    (.div.vf Q vf0 vf5 :ftf #b11 :fsf #b10)
    (.mov vf7 v1-0)
    (.add.x.vf vf6 vf0 vf7 :mask #b1000)
    (.wait.vf)
    (.mul.vf vf6 vf4 Q :mask #b10)
    (.nop.vf)
    (.nop.vf)
    (.svf arg0 vf6)
    arg0))

(defun vector-*! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float))
  "TODO"
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.mov vf7 arg3)
    (.lvf vf5 arg2)
    (.lvf vf4 arg1)
    (.add.x.vf vf6 vf0 vf0 :mask #b1)
    (.mul.w.vf acc vf4 vf0 :mask #b1110)
    (.sub.mul.x.vf vf6 vf5 vf7 acc :mask #b1110)
    (.svf arg0 vf6)
    arg0))

(defun vector+*! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float))
  "TODO"
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf))
    (.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0))
    (.mov vf7 arg3)
    (.lvf vf5 arg2)
    (.lvf vf4 arg1)
    (.add.x.vf vf6 vf0 vf0 :mask #b1)
    (.mul.x.vf acc vf5 vf7 :mask #b1110)
    (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b1110)
    (.svf arg0 vf6)
    arg0))

(defun vector*! ((arg0 vector) (arg1 vector) (arg2 vector))
  "TODO"
  (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))
    (.lvf vf4 arg1)
    (.lvf vf5 arg2)
    (.add.x.vf vf6 vf0 vf0 :mask #b1)
    (.mul.vf vf6 vf4 vf5 :mask #b1110)
    (.svf arg0 vf6)
    arg0))

(defun vector+float! ((arg0 vector) (arg1 vector) (arg2 float))
  "TODO"
  (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))
    (.mov vf6 arg2)
    (.lvf vf4 arg1)
    (.add.x.vf vf5 vf0 vf0 :mask #b1)
    (.add.x.vf vf5 vf4 vf6 :mask #b1110)
    (.svf arg0 vf5)
    arg0))

(defun vector-cross! ((arg0 vector) (arg1 vector) (arg2 vector))
  "TODO"
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf2 :class vf)
         (vf3 :class vf))
    (.lvf vf1 arg1)
    (.lvf vf2 arg2)
    (.outer.product.vf vf3 vf1 vf2)
    (.svf arg0 vf3)
    arg0))