jak-project/test/decompiler/reference/jak2/engine/math/trigonometry_REF.gc

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

;; definition for function radmod
(defun radmod ((arg0 float))
  (let ((f0-1 (+ 3.1415925 arg0)))
    (if (< 0.0 f0-1)
        (+ -3.1415925 (- f0-1 (* (the float (the int (/ f0-1 6.283185))) 6.283185)))
        (+ 3.1415925 (- f0-1 (* (the float (the int (/ f0-1 6.283185))) 6.283185)))
        )
    )
  )

;; definition for function deg-
(defun deg- ((arg0 float) (arg1 float))
  (the float (sar (- (shl (the int arg0) 48) (shl (the int arg1) 48)) 48))
  )

;; definition for function deg-diff
(defun deg-diff ((arg0 float) (arg1 float))
  (the float (sar (- (shl (the int arg1) 48) (shl (the int arg0) 48)) 48))
  )

;; definition for function deg-seek
(defun deg-seek ((arg0 float) (arg1 float) (arg2 float))
  (let ((v1-1 (shl (the int arg0) 48))
        (a0-2 (shl (the int arg1) 48))
        )
    (let* ((a1-2 (shl (the int arg2) 48))
           (a2-1 (- a0-2 v1-1))
           (a3-0 (abs a2-1))
           )
      (set! a0-2 (cond
                   ((< a3-0 0)
                    (+ v1-1 a1-2)
                    )
                   ((>= a1-2 a3-0)
                    (empty)
                    a0-2
                    )
                   ((>= a2-1 0)
                    (+ v1-1 a1-2)
                    )
                   (else
                     (- v1-1 a1-2)
                     )
                   )
            )
      )
    (the float (sar a0-2 48))
    )
  )

;; definition for function deg-seek-smooth
(defun deg-seek-smooth ((arg0 float) (arg1 float) (arg2 float) (arg3 float))
  (let ((f0-1 (* (deg- arg1 arg0) arg3)))
    (if (< arg2 (fabs f0-1))
        (set! f0-1 (if (>= f0-1 0.0)
                       arg2
                       (- arg2)
                       )
              )
        )
    (+ arg0 f0-1)
    )
  )

;; definition for function deg-lerp-clamp
(defun deg-lerp-clamp ((arg0 float) (arg1 float) (arg2 float))
  (cond
    ((>= 0.0 arg2)
     arg0
     )
    ((>= arg2 1.0)
     arg1
     )
    (else
      (the float (sar (shl (the int (+ arg0 (* arg2 (deg-diff arg0 arg1)))) 48) 48))
      )
    )
  )

;; definition for symbol binary-table, type (array float)
(define binary-table (new 'static 'boxed-array :type float
                       1.0
                       0.5
                       0.25
                       0.125
                       0.0625
                       0.03125
                       0.015625
                       0.0078125
                       0.00390625
                       0.001953125
                       0.0009765625
                       0.00048828125
                       0.00024414062
                       0.00012207031
                       0.000061035156
                       0.000030517578
                       0.000015258789
                       0.0000076293945
                       0.0000038146973
                       0.0000019073486
                       0.0000009536743
                       0.00000047683716
                       0.00000023841858
                       0.00000011920929
                       0.000000059604645
                       0.000000029802322
                       0.000000014901161
                       0.000000007450581
                       0.0000000037252903
                       0.0000000018626451
                       0.0000000009313226
                       0.0000000004656613
                       )
        )

;; definition for symbol sincos-table, type (array float)
(define sincos-table (new 'static 'boxed-array :type float
                       0.7853982
                       0.4636476
                       0.24497867
                       0.124354996
                       0.06241881
                       0.031239834
                       0.015623729
                       0.007812341
                       0.0039062302
                       0.0019531226
                       0.0009765622
                       0.0004882812
                       0.00024414062
                       0.00012207031
                       0.000061035156
                       0.000030517578
                       0.000015258789
                       0.0000076293945
                       0.0000038146973
                       0.0000019073486
                       0.0000009536743
                       0.00000047683716
                       0.00000023841858
                       0.00000011920929
                       0.000000059604645
                       0.000000029802322
                       0.000000014901161
                       0.000000007450581
                       0.0000000037252903
                       0.0000000018626451
                       0.0000000009313226
                       0.0000000004656613
                       )
        )

;; definition for function sin
(defun sin ((arg0 float))
  (let ((f2-0 (* 0.000095873795 (the float (sar (shl (the int arg0) 48) 48)))))
    f2-0
    (let* ((f1-4 (* 0.999998 f2-0))
           (f0-3 (* f2-0 f2-0))
           (f2-1 (* f2-0 f0-3))
           (f1-5 (+ f1-4 (* -0.16666014 f2-1)))
           (f2-2 (* f2-1 f0-3))
           (f1-6 (+ f1-5 (* 0.008326521 f2-2)))
           (f2-3 (* f2-2 f0-3))
           (f1-7 (+ f1-6 (* -0.0001956241 f2-3)))
           (f0-4 (* f2-3 f0-3))
           )
      (+ f1-7 (* 0.0000023042373 f0-4))
      )
    )
  )

;; definition for function sin-rad
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for symbol *sin-poly-vec*, type vector
(define *sin-poly-vec*
  (new 'static 'vector :x -0.16666014 :y 0.008326521 :z -0.0001956241 :w 0.0000023042373)
  )

;; definition for symbol *sin-poly-vec2*, type vector
(define *sin-poly-vec2* (new 'static 'vector :x 0.999998))

;; definition for function vector-sin-rad!
(defun vector-sin-rad! ((arg0 vector) (arg1 vector))
  (rlet ((acc :class vf)
         (vf1 :class vf)
         (vf10 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         (vf8 :class vf)
         (vf9 :class vf)
         )
    (.lvf vf1 (&-> arg1 quad))
    (.mul.vf vf3 vf1 vf1)
    (.lvf vf10 (&-> *sin-poly-vec2* quad))
    (.lvf vf9 (&-> *sin-poly-vec* quad))
    (.mul.vf vf4 vf3 vf1)
    (.mul.vf vf5 vf3 vf3)
    (.mul.x.vf acc vf1 vf10)
    (.mul.vf vf6 vf4 vf3)
    (.mul.vf vf7 vf5 vf4)
    (.add.mul.x.vf acc vf4 vf9 acc)
    (.mul.vf vf8 vf6 vf5)
    (.add.mul.y.vf acc vf6 vf9 acc)
    (.add.mul.z.vf acc vf7 vf9 acc)
    (.add.mul.w.vf vf2 vf8 vf9 acc)
    (.svf (&-> arg0 quad) vf2)
    arg0
    )
  )

;; definition for function cos-rad
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for symbol *cos-poly-vec*, type vector
(define *cos-poly-vec* (new 'static 'vector :x -0.49998003 :y 0.041620404 :z -0.0013636408 :w 0.000020170546))

;; definition for function vector-cos-rad!
;; ERROR: Bad vector register dependency: vf2
(defun vector-cos-rad! ((arg0 vector) (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)
         (vf9 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg1 quad))
    (.sub.vf vf2 vf2 vf2)
    (.lvf vf9 (&-> *cos-poly-vec* quad))
    (.mul.vf vf3 vf1 vf1)
    (.add.w.vf acc vf2 vf0)
    (.mul.vf vf4 vf3 vf3)
    (.add.mul.x.vf acc vf3 vf9 acc)
    (.mul.vf vf5 vf4 vf3)
    (.add.mul.y.vf acc vf4 vf9 acc)
    (.mul.vf vf6 vf4 vf4)
    (.add.mul.z.vf acc vf5 vf9 acc)
    (.add.mul.w.vf vf2 vf6 vf9 acc)
    (.svf (&-> arg0 quad) vf2)
    arg0
    )
  )

;; definition for function vector-sincos-rad!
;; ERROR: Bad vector register dependency: vf14
(defun vector-sincos-rad! ((arg0 vector) (arg1 vector) (arg2 vector))
  (rlet ((acc :class vf)
         (vf0 :class vf)
         (vf1 :class vf)
         (vf10 :class vf)
         (vf11 :class vf)
         (vf12 :class vf)
         (vf13 :class vf)
         (vf14 :class vf)
         (vf2 :class vf)
         (vf3 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         (vf7 :class vf)
         (vf8 :class vf)
         (vf9 :class vf)
         )
    (init-vf0-vector)
    (.lvf vf1 (&-> arg2 quad))
    (.sub.vf vf14 vf14 vf14)
    (.lvf vf11 (&-> *sin-poly-vec2* quad))
    (.mul.vf vf2 vf1 vf1)
    (.lvf vf10 (&-> *sin-poly-vec* quad))
    (.lvf vf13 (&-> *cos-poly-vec* quad))
    (.mul.x.vf acc vf1 vf11)
    (.mul.vf vf3 vf2 vf1)
    (.mul.vf vf4 vf2 vf2)
    (.mul.vf vf5 vf3 vf2)
    (.mul.vf vf6 vf3 vf3)
    (.mul.vf vf7 vf4 vf3)
    (.mul.vf vf8 vf4 vf4)
    (.mul.vf vf9 vf5 vf4)
    (.add.mul.x.vf acc vf3 vf10 acc)
    (.add.mul.y.vf acc vf5 vf10 acc)
    (.add.mul.z.vf acc vf7 vf10 acc)
    (.add.mul.w.vf vf12 vf9 vf10 acc)
    (.add.w.vf acc vf14 vf0)
    (.add.mul.x.vf acc vf2 vf13 acc)
    (.add.mul.y.vf acc vf4 vf13 acc)
    (.add.mul.z.vf acc vf6 vf13 acc)
    (.add.mul.w.vf vf14 vf8 vf13 acc)
    (.svf (&-> arg0 quad) vf12)
    (.svf (&-> arg1 quad) vf14)
    0
    )
  )

;; definition for function sincos-rad!
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for function sincos!
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for function vector-rad<-vector-deg!
;; WARN: Return type mismatch float vs none.
(defun vector-rad<-vector-deg! ((arg0 vector) (arg1 vector))
  (local-vars (v0-0 float) (v1-1 uint128) (v1-2 uint128) (v1-3 uint128))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
    (let ((v1-0 #x38c90fda))
      (.lvf vf1 (&-> arg1 quad))
      (.ftoi.vf vf1 vf1)
      (.mov vf2 v1-0)
      )
    (.mov v1-1 vf1)
    (.pw.sll v1-2 v1-1 16)
    (.pw.sra v1-3 v1-2 16)
    (.mov vf1 v1-3)
    (.itof.vf vf1 vf1)
    (.mul.x.vf vf1 vf1 vf2)
    (.svf (&-> arg0 quad) vf1)
    (.mov v0-0 vf1)
    (none)
    )
  )

;; definition for function vector-rad<-vector-deg/2!
;; WARN: Return type mismatch float vs int.
(defun vector-rad<-vector-deg/2! ((arg0 vector) (arg1 vector))
  (local-vars (v0-0 float) (v1-1 uint128) (v1-2 uint128) (v1-3 uint128))
  (rlet ((vf1 :class vf)
         (vf2 :class vf)
         )
    (let ((v1-0 #x38c90fda))
      (let ((a2-0 #x3f000000))
        (.lvf vf1 (&-> arg1 quad))
        (.mov vf2 a2-0)
        )
      (.mul.x.vf vf1 vf1 vf2)
      (.ftoi.vf vf1 vf1)
      (.mov vf2 v1-0)
      )
    (.mov v1-1 vf1)
    (.pw.sll v1-2 v1-1 16)
    (.pw.sra v1-3 v1-2 16)
    (.mov vf1 v1-3)
    (.itof.vf vf1 vf1)
    (.mul.x.vf vf1 vf1 vf2)
    (.svf (&-> arg0 quad) vf1)
    (.mov v0-0 vf1)
    (the-as int v0-0)
    )
  )

;; definition for function vector-sincos!
(defun vector-sincos! ((arg0 vector) (arg1 vector) (arg2 vector))
  (let ((s4-0 (new 'stack-no-clear 'vector)))
    (vector-rad<-vector-deg! s4-0 arg2)
    (vector-sincos-rad! arg0 arg1 s4-0)
    )
  )

;; definition for function tan-rad
(defun tan-rad ((arg0 float))
  (/ (sin arg0) (cos arg0))
  )

;; definition for function cos
(defun cos ((arg0 float))
  (sin (+ 16384.0 arg0))
  )

;; definition for function tan
(defun tan ((arg0 float))
  (/ (sin arg0) (cos arg0))
  )

;; definition for function atan0
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for function atan-series-rad
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for function atan-rad
(defun atan-rad ((arg0 float))
  (atan-series-rad (/ (+ -1.0 arg0) (+ 1.0 arg0)))
  )

;; definition for function sign-bit
(defun sign-bit ((arg0 int))
  (local-vars (v1-1 int))
  (let ((v1-0 arg0))
    (shift-arith-right-32 v1-1 v1-0 31)
    )
  (logand v1-1 1)
  )

;; definition for function sign-float
;; ERROR: function was not converted to expressions. Cannot decompile.

;; definition for function sign
(defun sign ((arg0 float))
  (cond
    ((< 0.0 arg0)
     1.0
     )
    ((< arg0 0.0)
     -1.0
     )
    (else
      0.0
      )
    )
  )

;; definition for function atan2-rad
(defun atan2-rad ((arg0 float) (arg1 float))
  (cond
    ((= arg1 0.0)
     (* 1.5707963 (sign arg0))
     )
    ((and (< arg0 0.0) (< arg1 0.0))
     (let ((f30-1 -3.1415925)
           (f0-6 (/ arg0 arg1))
           )
       (+ f30-1 (atan-series-rad (/ (+ -1.0 f0-6) (+ 1.0 f0-6))))
       )
     )
    ((< arg0 0.0)
     (let ((f0-14 (- (/ arg0 arg1))))
       (- (atan-series-rad (/ (+ -1.0 f0-14) (+ 1.0 f0-14))))
       )
     )
    ((< arg1 0.0)
     (let ((f30-2 3.1415925)
           (f0-22 (- (/ arg0 arg1)))
           )
       (- f30-2 (atan-series-rad (/ (+ -1.0 f0-22) (+ 1.0 f0-22))))
       )
     )
    (else
      (let ((f0-28 (/ arg0 arg1)))
        (atan-series-rad (/ (+ -1.0 f0-28) (+ 1.0 f0-28)))
        )
      )
    )
  )

;; definition for function atan
(defun atan ((arg0 float) (arg1 float))
  (cond
    ((and (= arg1 0.0) (= arg0 0.0))
     0.0
     )
    ((and (< arg1 0.0) (< arg0 0.0))
     (+ -32768.0 (atan0 (- arg0) (- arg1)))
     )
    ((< arg0 0.0)
     (- (atan0 (- arg0) arg1))
     )
    ((< arg1 0.0)
     (- 32768.0 (atan0 arg0 (- arg1)))
     )
    (else
      (atan0 arg0 arg1)
      )
    )
  )

;; definition for function asin
(defun asin ((arg0 float))
  (let ((gp-0 #f))
    0.0
    (when (< arg0 0.0)
      (set! arg0 (- arg0))
      (set! gp-0 #t)
      )
    (let ((f0-5 (cond
                  ((< 1.0 arg0)
                   16383.996
                   )
                  (else
                    (let* ((f0-6 1.0)
                           (f1-2 arg0)
                           (f0-8 (sqrtf (- f0-6 (* f1-2 f1-2))))
                           )
                      (atan0 arg0 f0-8)
                      )
                    )
                  )
                )
          )
      (if gp-0
          (- f0-5)
          f0-5
          )
      )
    )
  )

;; definition for function acos
(defun acos ((arg0 float))
  (- 16384.0 (asin arg0))
  )

;; definition for function acos-rad
(defun acos-rad ((arg0 float))
  (cond
    ((>= arg0 0.0)
     (let* ((f0-1 1.0)
            (f1-1 arg0)
            (f0-3 (sqrtf (- f0-1 (* f1-1 f1-1))))
            (f0-5 (/ (- f0-3 arg0) (+ f0-3 arg0)))
            )
       (atan-series-rad f0-5)
       )
     )
    (else
      (let* ((f0-6 1.0)
             (f1-6 arg0)
             (f0-8 (sqrtf (- f0-6 (* f1-6 f1-6))))
             (f0-10 (/ (+ f0-8 arg0) (- f0-8 arg0)))
             )
        (- 3.1415925 (atan-series-rad f0-10))
        )
      )
    )
  )

;; definition for function sinerp
(defun sinerp ((arg0 float) (arg1 float) (arg2 float))
  (lerp arg0 arg1 (sin (* 16384.0 arg2)))
  )

;; definition for function sinerp-clamp
(defun sinerp-clamp ((arg0 float) (arg1 float) (arg2 float))
  (cond
    ((>= 0.0 arg2)
     arg0
     )
    ((>= arg2 1.0)
     arg1
     )
    (else
      (sinerp arg0 arg1 arg2)
      )
    )
  )

;; definition for function coserp
(defun coserp ((arg0 float) (arg1 float) (arg2 float))
  (lerp arg0 arg1 (- 1.0 (cos (* 16384.0 arg2))))
  )

;; definition for function coserp-clamp
(defun coserp-clamp ((arg0 float) (arg1 float) (arg2 float))
  (cond
    ((>= 0.0 arg2)
     arg0
     )
    ((>= arg2 1.0)
     arg1
     )
    (else
      (coserp arg0 arg1 arg2)
      )
    )
  )

;; definition for function coserp180
(defun coserp180 ((arg0 float) (arg1 float) (arg2 float))
  (lerp arg0 arg1 (* 0.5 (- 1.0 (cos (* 32768.0 arg2)))))
  )

;; definition for function coserp180-clamp
(defun coserp180-clamp ((arg0 float) (arg1 float) (arg2 float))
  (cond
    ((>= 0.0 arg2)
     arg0
     )
    ((>= arg2 1.0)
     arg1
     )
    (else
      (coserp180 arg0 arg1 arg2)
      )
    )
  )

;; definition for function ease-in-out
(defun ease-in-out ((arg0 int) (arg1 int))
  (local-vars (v1-0 int))
  (cond
    ((>= arg1 arg0)
     1.0
     )
    ((<= arg1 0)
     0.0
     )
    ((begin (set! v1-0 (/ arg0 2)) (< v1-0 arg1))
     (let ((a0-1 (- arg1 arg0)))
       (+ 0.5 (* 0.5 (sin (- 16384.0 (/ (* 16384.0 (the float a0-1)) (the float v1-0))))))
       )
     )
    (else
      (- 0.5 (* 0.5 (cos (/ (* 16384.0 (the float arg1)) (the float v1-0)))))
      )
    )
  )