mirror of
https://github.com/open-goal/jak-project
synced 2026-05-23 23:05:43 -04:00
water111
637990314b
Closes #736 --------- Co-authored-by: Hat Kid <6624576+Hat-Kid@users.noreply.github.com>
766 lines
20 KiB
Common Lisp
Vendored
Generated
766 lines
20 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition for function truncate
|
|
(defun truncate ((arg0 float))
|
|
"Round (toward zero) to an integer.
|
|
@param arg0 float to truncate"
|
|
(the float (the int arg0))
|
|
)
|
|
|
|
;; definition for function round
|
|
(defun round ((arg0 float))
|
|
"Round to the nearest integer"
|
|
(the float (the int (+ 0.5 arg0)))
|
|
)
|
|
|
|
;; definition for function floor
|
|
(defun floor ((arg0 float))
|
|
"Round (down) to an integer"
|
|
(let ((f0-3 (the float (the int arg0))))
|
|
(if (or (>= arg0 0.0) (= arg0 f0-3))
|
|
f0-3
|
|
(+ -1.0 f0-3)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function ceil
|
|
(defun ceil ((arg0 float))
|
|
"Round (up) to an integer"
|
|
(let ((f0-3 (the float (the int arg0))))
|
|
(if (or (>= 0.0 arg0) (= arg0 f0-3))
|
|
f0-3
|
|
(+ 1.0 f0-3)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function integral?
|
|
(defun integral? ((arg0 float))
|
|
"Is this number an integer?"
|
|
(= (the float (the int arg0)) arg0)
|
|
)
|
|
|
|
;; definition for function fractional-part
|
|
(defun fractional-part ((arg0 float))
|
|
"Get the fractional part of a float."
|
|
(- arg0 (the float (the int arg0)))
|
|
)
|
|
|
|
;; definition for function odd?
|
|
(defun odd? ((arg0 int))
|
|
"Is the number odd?"
|
|
(= (logand arg0 1) 1)
|
|
)
|
|
|
|
;; definition for function even?
|
|
(defun even? ((arg0 int))
|
|
"Is the number even?"
|
|
(not (odd? arg0))
|
|
)
|
|
|
|
;; definition for function sawtooth-wave
|
|
(defun sawtooth-wave ((arg0 float))
|
|
"Sample a sawtooth with period 1. In range (0, 1)"
|
|
(let ((f0-2 (- arg0 (the float (the int arg0)))))
|
|
(if (< f0-2 0.0)
|
|
(set! f0-2 (+ 1.0 f0-2))
|
|
)
|
|
f0-2
|
|
)
|
|
)
|
|
|
|
;; definition for function triangle-wave
|
|
(defun triangle-wave ((arg0 float))
|
|
"Sample a triangle wave. Period is 4, in range (-1, 1) (so slope is 1 or -1)."
|
|
(let* ((f0-1 (* 0.25 (+ -1.0 arg0)))
|
|
(f0-3 (- f0-1 (the float (the int f0-1))))
|
|
)
|
|
(if (< f0-3 0.0)
|
|
(set! f0-3 (+ 1.0 f0-3))
|
|
)
|
|
(+ -1.0 (fabs (+ -2.0 (* 4.0 f0-3))))
|
|
)
|
|
)
|
|
|
|
;; definition for function log-x-plus-1-order9
|
|
(defun log-x-plus-1-order9 ((arg0 float))
|
|
"Fast approximation of ln(x + 1). Probably only accurate for x in [0, 1]."
|
|
(* arg0
|
|
(+ 1.0
|
|
(* arg0
|
|
(+ -0.5
|
|
(* arg0
|
|
(+ 0.33333334
|
|
(* arg0
|
|
(+ -0.25 (* arg0 (+ 0.2 (* arg0 (+ -0.16666666 (* arg0 (+ 0.14285715 (* arg0 (+ -0.125 (/ arg0 9))))))))))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function logf
|
|
(defun logf ((arg0 float))
|
|
"Natural log."
|
|
(let ((v1-1 (the-as int (+ (shr (the-as int arg0) 23) -126)))
|
|
(a0-2 (the-as number (logior #x3f000000 (logand (the-as uint #x807fffff) (the-as uint arg0)))))
|
|
)
|
|
(when (< (the-as float (gpr->fpr (the-as int a0-2))) 0.70710677)
|
|
(set! a0-2 (+ (the-as float (gpr->fpr (the-as int a0-2))) (the-as float (gpr->fpr (the-as int a0-2)))))
|
|
(set! v1-1 (the-as int (+ (the-as uint v1-1) -1)))
|
|
)
|
|
(let ((f0-5 (+ -1.0 (the-as float (gpr->fpr a0-2)))))
|
|
(+ (* f0-5
|
|
(+ 1.0
|
|
(* f0-5
|
|
(+ -0.5
|
|
(* f0-5
|
|
(+ 0.33333334
|
|
(* f0-5
|
|
(+ -0.25 (* f0-5 (+ 0.2 (* f0-5 (+ -0.16666666 (* f0-5 (+ 0.14285715 (* f0-5 (+ -0.125 (/ f0-5 9))))))))))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(* 0.6931472 (the float v1-1))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function log2f
|
|
(defun log2f ((arg0 float))
|
|
"Log base 2."
|
|
(let ((v1-1 (the-as int (+ (shr (the-as int arg0) 23) -126)))
|
|
(a0-2 (the-as number (logior #x3f000000 (logand (the-as uint #x807fffff) (the-as uint arg0)))))
|
|
)
|
|
(when (< (the-as float (gpr->fpr (the-as int a0-2))) 0.70710677)
|
|
(set! a0-2 (+ (the-as float (gpr->fpr (the-as int a0-2))) (the-as float (gpr->fpr (the-as int a0-2)))))
|
|
(set! v1-1 (the-as int (+ (the-as uint v1-1) -1)))
|
|
)
|
|
(let* ((f0-5 (+ -1.0 (the-as float (gpr->fpr a0-2))))
|
|
(f0-7
|
|
(* f0-5
|
|
(+ 1.0
|
|
(* f0-5
|
|
(+ -0.5
|
|
(* f0-5
|
|
(+ 0.33333334
|
|
(* f0-5
|
|
(+ -0.25 (* f0-5 (+ 0.2 (* f0-5 (+ -0.16666666 (* f0-5 (+ 0.14285715 (* f0-5 (+ -0.125 (/ f0-5 9))))))))))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(+ (* 1.442695 f0-7) (the float v1-1))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition of type float-type
|
|
(deftype float-type (uint32)
|
|
()
|
|
)
|
|
|
|
;; definition for symbol exp-slead, type (pointer float)
|
|
(define exp-slead (new 'static 'array float 32
|
|
1.0
|
|
1.0218964
|
|
1.0442734
|
|
1.0671387
|
|
1.0905075
|
|
1.1143799
|
|
1.1387863
|
|
1.1637192
|
|
1.1892014
|
|
1.2152405
|
|
1.2418518
|
|
1.2690506
|
|
1.2968369
|
|
1.3252335
|
|
1.354248
|
|
1.3839035
|
|
1.4142075
|
|
1.4451752
|
|
1.4768219
|
|
1.5091629
|
|
1.5422058
|
|
1.5759735
|
|
1.6104889
|
|
1.645752
|
|
1.6817856
|
|
1.7186127
|
|
1.7562485
|
|
1.7947083
|
|
1.8340073
|
|
1.8741608
|
|
1.9151993
|
|
1.9571381
|
|
)
|
|
)
|
|
|
|
;; definition for symbol exp-strail, type (pointer float)
|
|
(define exp-strail (new 'static 'array float 32
|
|
0.0
|
|
0.0000007863494
|
|
0.00000040596257
|
|
0.0000017288019
|
|
0.00000022534104
|
|
0.0000068597833
|
|
0.0000023188388
|
|
0.0000056815315
|
|
0.0000057600223
|
|
0.0000068814647
|
|
0.000006005433
|
|
0.0000003590472
|
|
0.0000027016238
|
|
0.000003183687
|
|
0.000007500062
|
|
0.000006378546
|
|
0.000006103877
|
|
0.0000056360786
|
|
0.0000042465254
|
|
0.0000015247614
|
|
0.000005014861
|
|
0.000007334366
|
|
0.0000014403477
|
|
0.000003525029
|
|
0.000007247011
|
|
0.000006627224
|
|
0.0000036862523
|
|
0.00000082304996
|
|
0.0000008232258
|
|
0.0000068675085
|
|
0.000007281612
|
|
0.000006062652
|
|
)
|
|
)
|
|
|
|
;; definition for function exp
|
|
;; ERROR: function was not converted to expressions. Cannot decompile.
|
|
|
|
;; definition for function pow
|
|
(defun pow ((arg0 float) (arg1 float))
|
|
"Compute arg0^arg1"
|
|
(exp (* arg1 (logf arg0)))
|
|
)
|
|
|
|
;; definition for function print-exp
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defun print-exp ((arg0 float))
|
|
"Print in the format AeB where A is in the range (1, 10)"
|
|
(let* ((f30-1 (floor (/ (logf (fabs arg0)) (logf 10.0))))
|
|
(f0-4 (pow 10.0 f30-1))
|
|
)
|
|
(format #t "~fe~d" (/ arg0 f0-4) (the int f30-1))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition of type rgba
|
|
(deftype rgba (uint32)
|
|
((r uint8 :offset 0 :size 8)
|
|
(g uint8 :offset 8 :size 8)
|
|
(b uint8 :offset 16 :size 8)
|
|
(a uint8 :offset 24 :size 8)
|
|
)
|
|
)
|
|
|
|
;; definition of type xyzw
|
|
(deftype xyzw (uint128)
|
|
()
|
|
)
|
|
|
|
;; definition of type xyzwh
|
|
(deftype xyzwh (uint128)
|
|
()
|
|
)
|
|
|
|
;; definition for function print-time
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defun print-time ((arg0 object) (arg1 time-frame))
|
|
"Print a [[time-frame]] as h:mm:ss."
|
|
0
|
|
0
|
|
0
|
|
(let* ((f0-1 (* 0.0033333334 (the float arg1)))
|
|
(a2-0 (the int (/ f0-1 60)))
|
|
(f0-2 (- f0-1 (* 60.0 (the float a2-0))))
|
|
(a3-0 (the int f0-2))
|
|
(f0-3 (- f0-2 (the float a3-0)))
|
|
(t0-0 (the int (* 100.0 f0-3)))
|
|
)
|
|
(format arg0 "~d:~2,'0,d:~2,'0,d" a2-0 a3-0 t0-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function log2
|
|
;; WARN: Return type mismatch uint vs int.
|
|
(defun log2 ((arg0 int))
|
|
"Log base 2."
|
|
(the-as int (+ (sar (the-as int (the float arg0)) 23) -127))
|
|
)
|
|
|
|
;; definition for function seek
|
|
(defun seek ((arg0 float) (arg1 float) (arg2 float))
|
|
"Move arg0 toward arg1 by at most arg2."
|
|
(let ((f2-0 (- arg1 arg0)))
|
|
(cond
|
|
((>= arg2 (fabs f2-0))
|
|
arg1
|
|
)
|
|
((>= f2-0 0.0)
|
|
(+ arg0 arg2)
|
|
)
|
|
(else
|
|
(- arg0 arg2)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function seek-ease
|
|
(defun seek-ease ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
|
|
"Move arg0 toward arg1, and slow down before reaching the end.
|
|
When farther than arg3 away, move by at most arg2.
|
|
When closer than arg3, linearly ramp down the movement amount from arg2 to 0 but no lower than arg4."
|
|
(let ((f2-0 (- arg1 arg0)))
|
|
(when (>= arg3 (fabs f2-0))
|
|
(set! arg2 (* arg2 (- 1.0 (/ (- arg3 (fabs f2-0)) arg3))))
|
|
(if (< arg2 arg4)
|
|
(set! arg2 arg4)
|
|
)
|
|
)
|
|
(cond
|
|
((>= arg2 (fabs f2-0))
|
|
arg1
|
|
)
|
|
((>= f2-0 0.0)
|
|
(+ arg0 arg2)
|
|
)
|
|
(else
|
|
(- arg0 arg2)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function seek-ease-in-out
|
|
(defun seek-ease-in-out ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float) (arg5 float) (arg6 float))
|
|
"Move arg0 toward arg2, and slow down at the start and end.
|
|
When within arg4 of arg1 (at the beginning of movement), ramp up speed, with a minimum speed of arg6
|
|
When within arg5 of arg2 (at the end of movement), ramp down speed, with a minimum speed of arg5
|
|
Normally, move at most arg3"
|
|
(let ((f2-0 (- arg2 arg0)))
|
|
(let ((f4-1 (- arg0 arg1)))
|
|
(when (>= arg4 (fabs f4-1))
|
|
(set! arg3 (* arg3 (- 1.0 (/ (- arg4 (fabs f4-1)) arg4))))
|
|
(if (< arg3 arg6)
|
|
(set! arg3 arg6)
|
|
)
|
|
)
|
|
)
|
|
(when (>= arg5 (fabs f2-0))
|
|
(set! arg3 (* arg3 (- 1.0 (/ (- arg5 (fabs f2-0)) arg5))))
|
|
(if (< arg3 arg6)
|
|
(set! arg3 arg6)
|
|
)
|
|
)
|
|
(cond
|
|
((>= arg3 (fabs f2-0))
|
|
arg2
|
|
)
|
|
((>= f2-0 0.0)
|
|
(+ arg0 arg3)
|
|
)
|
|
(else
|
|
(- arg0 arg3)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function lerp
|
|
(defun lerp ((arg0 float) (arg1 float) (arg2 float))
|
|
"Linearly interpolate between arg0 and arg1."
|
|
(+ arg0 (* arg2 (- arg1 arg0)))
|
|
)
|
|
|
|
;; definition (debug) for function lerp-scale-old
|
|
(defun-debug lerp-scale-old ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
|
|
"Linearly remap arg2 in [arg3, arg4] to [arg0, arg1].
|
|
This is the jak 1 implementation, which I claimed was a bad implementation..."
|
|
(let ((f0-1 (fmax 0.0 (fmin 1.0 (/ (- arg2 arg3) (- arg4 arg3))))))
|
|
(+ (* (- 1.0 f0-1) arg0) (* f0-1 arg1))
|
|
)
|
|
)
|
|
|
|
;; definition for function lerp-scale
|
|
;; ERROR: Unsupported inline assembly instruction kind - [mula.s f0, f2]
|
|
;; ERROR: Unsupported inline assembly instruction kind - [madd.s f0, f1, f3]
|
|
(defun lerp-scale ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
|
|
"Linearly remap arg2 in [arg3, arg4] to [arg0, arg1].
|
|
More efficient than the -old version."
|
|
(local-vars (f0-2 float))
|
|
(let* ((v1-0 1.0)
|
|
(f1-0 0.0)
|
|
(f0-0 v1-0)
|
|
(f4-0 arg2)
|
|
(f2-0 arg3)
|
|
(f3-0 arg4)
|
|
(f1-2 (fmin (fmax (/ (- f4-0 f2-0) (- f3-0 f2-0)) f1-0) f0-0))
|
|
(f0-1 (- f0-0 f1-2))
|
|
(f2-3 arg0)
|
|
(f3-1 arg1)
|
|
)
|
|
(.mula.s f0-1 f2-3)
|
|
(.madd.s f0-2 f1-2 f3-1)
|
|
)
|
|
f0-2
|
|
)
|
|
|
|
;; definition for function lerp-scale-clamp
|
|
(defun lerp-scale-clamp ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
|
|
"Clamp the input, then linearly remap arg2 in [arg3, arg4] to [arg0, arg1]."
|
|
(let ((a2-1 (fmax (fmin arg2 arg4) arg3)))
|
|
(lerp-scale arg0 arg1 a2-1 arg3 arg4)
|
|
)
|
|
)
|
|
|
|
;; definition for function lerp-clamp
|
|
(defun lerp-clamp ((arg0 float) (arg1 float) (arg2 float))
|
|
"Linearly interpolate between arg0 and arg1. arg2 is clamped to [0, 1]"
|
|
(cond
|
|
((>= 0.0 arg2)
|
|
arg0
|
|
)
|
|
((>= arg2 1.0)
|
|
arg1
|
|
)
|
|
(else
|
|
(+ (* (- 1.0 arg2) arg0) (* arg2 arg1))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function rgba-lerp
|
|
;; WARN: Return type mismatch int vs rgba.
|
|
(defun rgba-lerp ((arg0 rgba) (arg1 rgba) (arg2 rgba))
|
|
(local-vars
|
|
(v0-0 uint128)
|
|
(v1-0 uint128)
|
|
(v1-1 uint128)
|
|
(a0-1 uint128)
|
|
(a0-2 uint128)
|
|
(a1-1 uint128)
|
|
(a2-1 uint128)
|
|
)
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf1 :class vf)
|
|
(vf2 :class vf)
|
|
(vf3 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(.pextlb v1-0 0 arg0)
|
|
(.pextlb a0-1 0 arg1)
|
|
(.pextlh v1-1 0 v1-0)
|
|
(.pextlh a0-2 0 a0-1)
|
|
(.mov vf1 v1-1)
|
|
(.mov vf2 a0-2)
|
|
(.mov vf3 arg2)
|
|
(.itof.vf vf1 vf1)
|
|
(.itof.vf vf2 vf2)
|
|
(.mul.w.vf acc vf1 vf0)
|
|
(.add.mul.x.vf acc vf2 vf3 acc)
|
|
(.sub.mul.x.vf vf1 vf1 vf3 acc)
|
|
(.ftoi.vf vf3 vf1)
|
|
(.mov a1-1 vf3)
|
|
(.ppach a2-1 (the-as uint128 0) a1-1)
|
|
(.ppacb v0-0 (the-as uint128 0) a2-1)
|
|
(the-as rgba v0-0)
|
|
)
|
|
)
|
|
|
|
;; definition for function seekl
|
|
(defun seekl ((arg0 int) (arg1 int) (arg2 int))
|
|
"Move arg0 toward arg1, by at most arg2."
|
|
(let* ((v1-0 (- arg1 arg0))
|
|
(a3-0 (abs v1-0))
|
|
)
|
|
(cond
|
|
((>= arg2 a3-0)
|
|
arg1
|
|
)
|
|
((>= v1-0 0)
|
|
(+ arg0 arg2)
|
|
)
|
|
(else
|
|
(- arg0 arg2)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function rand-vu-init
|
|
;; WARN: Return type mismatch int vs float.
|
|
;; ERROR: Unsupported inline assembly instruction kind - [ctc2.i vi_R, a0]
|
|
;; ERROR: Unsupported inline assembly instruction kind - [cfc2.i v0, vi_R]
|
|
(defun rand-vu-init ((arg0 float))
|
|
"Initialize the VU0 random generator."
|
|
(local-vars (v0-0 int))
|
|
(.ctc2.i vi_R arg0)
|
|
(.cfc2.i v0-0 vi_R)
|
|
(the-as float v0-0)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(rand-vu-init 1.418091)
|
|
|
|
;; definition for function rand-vu
|
|
;; ERROR: Inline assembly instruction marked with TODO - [TODO.VRGET]
|
|
;; ERROR: Inline assembly instruction marked with TODO - [TODO.VRXOR]
|
|
;; ERROR: Inline assembly instruction marked with TODO - [TODO.VRNEXT]
|
|
(defun rand-vu ()
|
|
"Get a random number in [0, 1) and advance the random generator."
|
|
(local-vars (v0-0 float))
|
|
(rlet ((Q :class vf)
|
|
(vf0 :class vf)
|
|
(vf1 :class vf)
|
|
(vf2 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(TODO.VRGET vf1)
|
|
(.sqrt.vf Q vf1 :ftf #b0)
|
|
(.add.vf.x vf2 vf0 Q)
|
|
(TODO.VRXOR vf2)
|
|
(TODO.VRNEXT vf1)
|
|
(.sub.w.vf vf1 vf1 vf0)
|
|
(.mov v0-0 vf1)
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition for function rand-vu-nostep
|
|
;; ERROR: Inline assembly instruction marked with TODO - [TODO.VRGET]
|
|
(defun rand-vu-nostep ()
|
|
"Get the number currently in the random generator.
|
|
This will be equal to the last call of (rand-vu).
|
|
This will not update the random generator."
|
|
(local-vars (v0-0 float))
|
|
(rlet ((vf0 :class vf)
|
|
(vf1 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(TODO.VRGET vf1)
|
|
(.sub.w.vf vf1 vf1 vf0)
|
|
(.mov v0-0 vf1)
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition for function rand-vu-float-range
|
|
(defun rand-vu-float-range ((arg0 float) (arg1 float))
|
|
"Get a random float in between arg0 and arg1."
|
|
(+ arg0 (* (rand-vu) (- arg1 arg0)))
|
|
)
|
|
|
|
;; definition for function rand-vu-percent?
|
|
(defun rand-vu-percent? ((arg0 float))
|
|
"Get a boolean that's true with the given probability (in 0, 1)."
|
|
(>= arg0 (rand-vu))
|
|
)
|
|
|
|
;; definition for function rand-vu-int-range
|
|
(defun rand-vu-int-range ((arg0 int) (arg1 int))
|
|
"Get an integer in the given range (inclusive)."
|
|
(if (< arg0 arg1)
|
|
(set! arg1 (+ arg1 1))
|
|
(set! arg0 (+ arg0 1))
|
|
)
|
|
(let ((f0-4 (rand-vu-float-range (the float arg0) (the float arg1))))
|
|
(if (< f0-4 0.0)
|
|
(set! f0-4 (+ -1.0 f0-4))
|
|
)
|
|
(the int f0-4)
|
|
)
|
|
)
|
|
|
|
;; definition for function rand-vu-int-count
|
|
(defun rand-vu-int-count ((arg0 int))
|
|
"Get an integer in the range [0, max)."
|
|
(the int (* (rand-vu) (the float arg0)))
|
|
)
|
|
|
|
;; definition for function rand-vu-int-count-excluding
|
|
;; WARN: new jak 2 until loop case, check carefully
|
|
(defun rand-vu-int-count-excluding ((arg0 int) (arg1 int))
|
|
"Get an integer in the range [0, arg0).
|
|
If bit n is set in arg1, exclude this value from being returned."
|
|
(let ((s4-0 0)
|
|
(s5-0 0)
|
|
)
|
|
(let ((v1-0 1))
|
|
(while (nonzero? arg0)
|
|
(+! arg0 -1)
|
|
(if (not (logtest? arg1 v1-0))
|
|
(+! s4-0 1)
|
|
)
|
|
(set! v1-0 (* v1-0 2))
|
|
)
|
|
)
|
|
(when (> s4-0 0)
|
|
(let ((v1-4 (the int (* (rand-vu) (the float s4-0))))
|
|
(a0-1 1)
|
|
)
|
|
(until #f
|
|
(while (logtest? arg1 a0-1)
|
|
(nop!)
|
|
(nop!)
|
|
(+! s5-0 1)
|
|
(set! a0-1 (* a0-1 2))
|
|
)
|
|
(if (zero? v1-4)
|
|
(goto cfg-14)
|
|
)
|
|
(+! v1-4 -1)
|
|
(+! s5-0 1)
|
|
(set! a0-1 (* a0-1 2))
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
(label cfg-14)
|
|
s5-0
|
|
)
|
|
)
|
|
|
|
;; definition for function rand-vu-int-range-exclude
|
|
;; WARN: new jak 2 until loop case, check carefully
|
|
(defun rand-vu-int-range-exclude ((arg0 int) (arg1 int) (arg2 int))
|
|
"Get an integer in the range [0, arg0), excluding arg2.
|
|
Note that this doesn't use bits like rand-vu-int-count-excluding."
|
|
(until #f
|
|
(let ((v1-0 (rand-vu-int-range arg0 arg1)))
|
|
(if (!= v1-0 arg2)
|
|
(return v1-0)
|
|
)
|
|
)
|
|
)
|
|
(the-as int #f)
|
|
)
|
|
|
|
;; definition of type random-generator
|
|
(deftype random-generator (basic)
|
|
((seed uint32)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type random-generator
|
|
(defmethod inspect ((this random-generator))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tseed: ~D~%" (-> this seed))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for symbol *random-generator*, type random-generator
|
|
(define *random-generator* (new 'global 'random-generator))
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> *random-generator* seed) (the-as uint #x666edd1e))
|
|
|
|
;; definition for function rand-uint31-gen
|
|
;; ERROR: function was not converted to expressions. Cannot decompile.
|
|
|
|
;; definition for function cube-root
|
|
(defun cube-root ((arg0 float))
|
|
"Cube root with cool trick that I don't understand."
|
|
(cond
|
|
((!= arg0 0.0)
|
|
(let* ((v1-0 arg0)
|
|
(a1-2 (+ (logand (shr (the-as int v1-0) 23) 255) -127))
|
|
(f0-1
|
|
(the-as
|
|
number
|
|
(gpr->fpr
|
|
(logior (logand (the-as uint #x807fffff) (the-as uint v1-0)) (shl (+ (/ (the-as int a1-2) 3) 127) 23))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(dotimes (v1-3 6)
|
|
(set! f0-1
|
|
(- (the-as float f0-1) (/ (- (* (the-as float (square (the-as float f0-1))) (the-as float f0-1)) arg0)
|
|
(* 3.0 (the-as float f0-1) (the-as float f0-1))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(the-as float f0-1)
|
|
)
|
|
)
|
|
(else
|
|
0.0
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function int-noise
|
|
(defun int-noise ((arg0 int))
|
|
"Generate random-ish floats in range -1, 1."
|
|
(let ((v1-1 (logxor (shl arg0 13) arg0)))
|
|
(- 1.0 (* 0.0000000009313226
|
|
(the float (logand #x7fffffff (+ #x5208dd0d (* v1-1 (+ #xc0ae5 (* (* #x3d73 v1-1) v1-1))))))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function smooth-step
|
|
(defun smooth-step ((arg0 float))
|
|
"Interpolate between 0, 1 with a cubic polynomial.
|
|
These are picked so f(0) = 0, f(1) = 1, f'(0) = f'(1) = 0."
|
|
(cond
|
|
((>= 0.0 arg0)
|
|
0.0
|
|
)
|
|
((>= arg0 1.0)
|
|
1.0
|
|
)
|
|
(else
|
|
(* arg0 arg0 (+ 3.0 (* -2.0 arg0)))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function smooth-interp
|
|
(defun smooth-interp ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float))
|
|
"Remap arg2 from (arg3, arg4) to (arg0, arg1), using cubic interpolation.
|
|
Satisfies:
|
|
- f(arg3) = arg0
|
|
- f(arg4) = arg1
|
|
- f'(arg3) = f'(arg4) = 0"
|
|
(+ arg0 (* (- arg1 arg0) (smooth-step (/ (- arg2 arg3) (- arg4 arg3)))))
|
|
)
|