mirror of
https://github.com/open-goal/jak-project
synced 2026-07-09 23:01:56 -04:00
Tyler Wilding
690 lines
22 KiB
Common Lisp
Vendored
Generated
690 lines
22 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type float-pair
|
|
(deftype float-pair (structure)
|
|
"Two floats. Specifies one point on a piecewise linear curve."
|
|
((first float)
|
|
(second float)
|
|
(x float :overlay-at first)
|
|
(y float :overlay-at second)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type float-pair
|
|
(defmethod inspect ((this float-pair))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this 'float-pair)
|
|
(format #t "~1Tfirst: ~f~%" (-> this first))
|
|
(format #t "~1Tsecond: ~f~%" (-> this second))
|
|
(format #t "~1Tx: ~f~%" (-> this first))
|
|
(format #t "~1Ty: ~f~%" (-> this second))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition of type float-pair-array
|
|
(deftype float-pair-array (inline-array-class)
|
|
"Array of points used to make a piecewise linear curve."
|
|
((data float-pair :inline :dynamic)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type float-pair-array
|
|
(defmethod inspect ((this float-pair-array))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tlength: ~D~%" (-> this length))
|
|
(format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
|
|
(format #t "~1Tdata[0] @ #x~X~%" (-> this data))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> float-pair-array heap-base) (the-as uint 16))
|
|
|
|
;; definition of type curve2d
|
|
(deftype curve2d (basic)
|
|
"Interface for evaluating a 2d curve.
|
|
The input is a float (x-position) and the output is a float (y-position).
|
|
The curve is over (0, 1). Values outside of the range are either clamped
|
|
or wrapped depending on the loop-behavior flag."
|
|
()
|
|
(:methods
|
|
(evaluate (_type_ float loop-behavior) float)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type curve2d
|
|
(defmethod inspect ((this curve2d))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition of type curve-color
|
|
(deftype curve-color (basic)
|
|
"Interface for evaluating a color curve. The input is a float, representing
|
|
progress through the curve, and the result is a floating point rgba color."
|
|
()
|
|
(:methods
|
|
(evaluate (_type_ float rgbaf loop-behavior) rgbaf)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type curve-color
|
|
(defmethod inspect ((this curve-color))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition of type curve2d-piecewise
|
|
(deftype curve2d-piecewise (curve2d)
|
|
"Implementation of 2d-curve for a piecewise linear curve.
|
|
Not particularly efficient - each evaluation needs to check each point."
|
|
((pts float-pair-array)
|
|
(default-loop-behavior uint64)
|
|
)
|
|
(:methods
|
|
(allocate! (_type_ int symbol symbol) none)
|
|
(curve2d-piecewise-method-11 (_type_) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type curve2d-piecewise
|
|
(defmethod inspect ((this curve2d-piecewise))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tpts: ~A~%" (-> this pts))
|
|
(format #t "~1Tdefault-loop-behavior: ~D~%" (-> this default-loop-behavior))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition of type curve2d-fast
|
|
(deftype curve2d-fast (curve2d)
|
|
"Implementation of 2d piecewise linear curve which tries to be faster.
|
|
While it is faster, it places the huge restriction that you can only have 4 points.
|
|
Note that the xs should be negative here."
|
|
((xs vector :inline)
|
|
(ys vector :inline)
|
|
(one-over-x-deltas vector :inline)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type curve2d-fast
|
|
(defmethod inspect ((this curve2d-fast))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Txs: #<vector @ #x~X>~%" (-> this xs))
|
|
(format #t "~1Tys: #<vector @ #x~X>~%" (-> this ys))
|
|
(format #t "~1Tone-over-x-deltas: #<vector @ #x~X>~%" (-> this one-over-x-deltas))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for function rgbaf-lerp!
|
|
(defun rgbaf-lerp! ((arg0 rgbaf) (arg1 rgbaf) (arg2 rgbaf) (arg3 float))
|
|
"Lerp all four components of rgba."
|
|
(vector-lerp! arg0 arg1 arg2 arg3)
|
|
(set! (-> arg0 w) (lerp (-> arg1 w) (-> arg2 w) arg3))
|
|
arg0
|
|
)
|
|
|
|
;; definition of type curve-color-fast
|
|
(deftype curve-color-fast (curve-color)
|
|
"Implementation of color curve which tries to be faster.
|
|
While it is faster, it again has the restriction that you only
|
|
get 4 piecewise sections."
|
|
((xs vector :inline)
|
|
(ys vector 4 :inline)
|
|
(one-over-x-deltas vector :inline)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type curve-color-fast
|
|
(defmethod inspect ((this curve-color-fast))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Txs: #<vector @ #x~X>~%" (-> this xs))
|
|
(format #t "~1Tys[4] @ #x~X~%" (-> this ys))
|
|
(format #t "~1Tone-over-x-deltas: #<vector @ #x~X>~%" (-> this one-over-x-deltas))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition of type color-pair
|
|
(deftype color-pair (structure)
|
|
"Single section of a piecewise linear color curve.
|
|
Unlike the fast version, this stores x values exactly like you'd expect."
|
|
((first float)
|
|
(second rgbaf :inline)
|
|
(x float :overlay-at first)
|
|
(y rgbaf :inline :overlay-at second)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type color-pair
|
|
(defmethod inspect ((this color-pair))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this 'color-pair)
|
|
(format #t "~1Tfirst: ~f~%" (-> this first))
|
|
(format #t "~1Tsecond: #<rgbaf @ #x~X>~%" (-> this second))
|
|
(format #t "~1Tx: ~f~%" (-> this first))
|
|
(format #t "~1Ty: #<rgbaf @ #x~X>~%" (-> this second))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition of type color-pair-array
|
|
(deftype color-pair-array (inline-array-class)
|
|
"Array of points for piecewise linear color curve."
|
|
((data color-pair :inline :dynamic)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type color-pair-array
|
|
(defmethod inspect ((this color-pair-array))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tlength: ~D~%" (-> this length))
|
|
(format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
|
|
(format #t "~1Tdata[0] @ #x~X~%" (-> this data))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> color-pair-array heap-base) (the-as uint 32))
|
|
|
|
;; definition of type curve-color-piecewise
|
|
(deftype curve-color-piecewise (curve-color)
|
|
"Implementation of curve-color."
|
|
((pts color-pair-array)
|
|
(default-loop-behavior uint64)
|
|
)
|
|
(:methods
|
|
(allocate! (_type_ int symbol symbol) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type curve-color-piecewise
|
|
(defmethod inspect ((this curve-color-piecewise))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tpts: ~A~%" (-> this pts))
|
|
(format #t "~1Tdefault-loop-behavior: ~D~%" (-> this default-loop-behavior))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for method 10 of type curve2d-piecewise
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod allocate! ((this curve2d-piecewise) (arg0 int) (arg1 symbol) (arg2 symbol))
|
|
"Allocate memory for points."
|
|
(set! (-> this pts) ((method-of-type float-pair-array new) arg1 float-pair-array arg0))
|
|
(set! (-> this default-loop-behavior) (the-as uint (if arg2
|
|
0
|
|
1
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 10 of type curve-color-piecewise
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod allocate! ((this curve-color-piecewise) (arg0 int) (arg1 symbol) (arg2 symbol))
|
|
"Allocate memory for points."
|
|
(set! (-> this pts) ((method-of-type color-pair-array new) arg1 color-pair-array arg0))
|
|
(set! (-> this default-loop-behavior) (the-as uint (if arg2
|
|
0
|
|
1
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 9 of type curve-color-piecewise
|
|
;; INFO: Used lq/sq
|
|
(defmethod evaluate ((this curve-color-piecewise) (arg0 float) (arg1 rgbaf) (arg2 loop-behavior))
|
|
(when (or (< 1.0 arg0) (< arg0 0.0))
|
|
(if (= arg2 (loop-behavior use-default))
|
|
(set! arg2 (the-as loop-behavior (-> this default-loop-behavior)))
|
|
)
|
|
(let ((v1-8 (the-as uint arg2)))
|
|
(cond
|
|
((zero? v1-8)
|
|
(set! arg0 (- arg0 (* (the float (the int (/ arg0 1.0))) 1.0)))
|
|
)
|
|
((= v1-8 1)
|
|
(set! arg0 (fmax 0.0 (fmin 1.0 arg0)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (= arg0 0.0)
|
|
(set! (-> arg1 quad) (-> this pts data 0 second quad))
|
|
(return arg1)
|
|
)
|
|
(dotimes (s4-0 (-> this pts length))
|
|
(when (>= (-> this pts data s4-0 first) arg0)
|
|
(let ((a3-4 (lerp-scale 0.0 1.0 arg0 (-> this pts data (+ s4-0 -1) first) (-> this pts data s4-0 first))))
|
|
(return (rgbaf-lerp!
|
|
arg1
|
|
(the-as rgbaf (+ (the-as uint (-> this pts data 0 second)) (* (+ s4-0 -1) 32)))
|
|
(the-as rgbaf (+ (the-as uint (-> this pts data 0 second)) (* s4-0 32)))
|
|
a3-4
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(the-as rgbaf #f)
|
|
)
|
|
|
|
;; definition for method 9 of type curve2d-piecewise
|
|
(defmethod evaluate ((this curve2d-piecewise) (arg0 float) (arg1 loop-behavior))
|
|
(when (or (< 1.0 arg0) (< arg0 0.0))
|
|
(if (= arg1 (loop-behavior use-default))
|
|
(set! arg1 (the-as loop-behavior (-> this default-loop-behavior)))
|
|
)
|
|
(let ((v1-8 (the-as uint arg1)))
|
|
(cond
|
|
((zero? v1-8)
|
|
(set! arg0 (- arg0 (* (the float (the int (/ arg0 1.0))) 1.0)))
|
|
)
|
|
((= v1-8 1)
|
|
(set! arg0 (fmax 0.0 (fmin 1.0 arg0)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(if (= arg0 0.0)
|
|
(return (-> this pts data 0 second))
|
|
)
|
|
(dotimes (v1-18 (-> this pts length))
|
|
(if (>= (-> this pts data v1-18 first) arg0)
|
|
(return (lerp-scale
|
|
(-> this pts data (+ v1-18 -1) second)
|
|
(-> this pts data v1-18 second)
|
|
arg0
|
|
(-> this pts data (+ v1-18 -1) first)
|
|
(-> this pts data v1-18 first)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0.0
|
|
)
|
|
|
|
;; definition for function evaluate-curve-fast
|
|
;; WARN: Return type mismatch number vs float.
|
|
(defun evaluate-curve-fast ((arg0 curve2d-fast) (arg1 float))
|
|
"Evaluate a curve2d-fast at the given value."
|
|
(local-vars (v0-0 number))
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf24 :class vf)
|
|
(vf25 :class vf)
|
|
(vf26 :class vf)
|
|
(vf27 :class vf)
|
|
(vf28 :class vf)
|
|
(vf29 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((a2-0 (new 'stack-no-clear 'vector))
|
|
(v1-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
(.mov vf27 arg1)
|
|
(.lvf vf24 (&-> arg0 xs quad))
|
|
(.lvf vf25 (&-> arg0 ys quad))
|
|
(.lvf vf26 (&-> arg0 one-over-x-deltas quad))
|
|
(.min.w.vf vf27 vf27 vf0)
|
|
(.max.x.vf vf27 vf27 vf0)
|
|
(.add.x.vf vf28 vf24 vf27)
|
|
(.mul.w.vf acc vf25 vf0)
|
|
(.add.mul.vf vf29 vf28 vf26 acc)
|
|
(.svf (&-> a2-0 quad) vf28)
|
|
(.svf (&-> v1-0 quad) vf29)
|
|
(let ((a0-1 (-> a2-0 z))
|
|
(a1-1 (-> a2-0 y))
|
|
)
|
|
(nop!)
|
|
(b! (>= (the-as int a0-1) 0) cfg-3 :delay (set! v0-0 (-> v1-0 z)))
|
|
(b! (>= (the-as int a1-1) 0) cfg-3 :delay (set! v0-0 (-> v1-0 y)))
|
|
)
|
|
(set! v0-0 (-> v1-0 x))
|
|
)
|
|
(label cfg-3)
|
|
(the-as float v0-0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 9 of type curve2d-fast
|
|
;; WARN: Return type mismatch number vs float.
|
|
(defmethod evaluate ((this curve2d-fast) (arg0 float) (arg1 loop-behavior))
|
|
(local-vars (v0-0 number))
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf24 :class vf)
|
|
(vf25 :class vf)
|
|
(vf26 :class vf)
|
|
(vf27 :class vf)
|
|
(vf28 :class vf)
|
|
(vf29 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((a1-1 (new 'stack-no-clear 'vector))
|
|
(v1-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
(let ((a2-1 arg0))
|
|
(.mov vf27 a2-1)
|
|
)
|
|
(.lvf vf24 (&-> this xs quad))
|
|
(.lvf vf25 (&-> this ys quad))
|
|
(.lvf vf26 (&-> this one-over-x-deltas quad))
|
|
(.min.w.vf vf27 vf27 vf0)
|
|
(.max.x.vf vf27 vf27 vf0)
|
|
(.add.x.vf vf28 vf24 vf27)
|
|
(.mul.w.vf acc vf25 vf0)
|
|
(.add.mul.vf vf29 vf28 vf26 acc)
|
|
(.svf (&-> a1-1 quad) vf28)
|
|
(.svf (&-> v1-0 quad) vf29)
|
|
(let ((a0-1 (-> a1-1 z))
|
|
(a1-2 (-> a1-1 y))
|
|
)
|
|
(nop!)
|
|
(b! (>= (the-as int a0-1) 0) cfg-3 :delay (set! v0-0 (-> v1-0 z)))
|
|
(b! (>= (the-as int a1-2) 0) cfg-3 :delay (set! v0-0 (-> v1-0 y)))
|
|
)
|
|
(set! v0-0 (-> v1-0 x))
|
|
)
|
|
(label cfg-3)
|
|
(the-as float v0-0)
|
|
)
|
|
)
|
|
|
|
;; definition for function evaluate-color-curve-fast
|
|
(defun evaluate-color-curve-fast ((arg0 curve-color-fast) (arg1 float) (arg2 rgbaf))
|
|
"Evaluate a color-curve-fast at the given value."
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf1 :class vf)
|
|
(vf2 :class vf)
|
|
(vf23 :class vf)
|
|
(vf25 :class vf)
|
|
(vf26 :class vf)
|
|
(vf28 :class vf)
|
|
(vf3 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((v1-0 (new 'stack-no-clear 'vector)))
|
|
(.mov vf26 arg1)
|
|
(.lvf vf23 (&-> arg0 xs quad))
|
|
(.lvf vf25 (&-> arg0 one-over-x-deltas quad))
|
|
(.max.w.vf vf3 vf0 vf0)
|
|
(.mul.vf acc vf25 vf23)
|
|
(.add.mul.x.vf vf28 vf25 vf26 acc)
|
|
(.svf (&-> v1-0 quad) vf28)
|
|
(let ((a1-1 (-> v1-0 z))
|
|
(v1-1 (-> v1-0 y))
|
|
)
|
|
(b! (>= (the-as int a1-1) 0) cfg-4 :delay (nop!))
|
|
(b! (>= (the-as int v1-1) 0) cfg-3 :delay (nop!))
|
|
)
|
|
)
|
|
(.lvf vf1 (&-> arg0 ys 0 quad))
|
|
(.lvf vf2 (&-> arg0 ys 1 quad))
|
|
(.sub.x.vf vf4 vf3 vf28)
|
|
(.mul.x.vf acc vf2 vf28)
|
|
(.add.mul.x.vf vf5 vf1 vf4 acc)
|
|
(b! #t cfg-5 :delay (.svf (&-> arg2 quad) vf5))
|
|
(label cfg-3)
|
|
(.lvf vf1 (&-> arg0 ys 1 quad))
|
|
(.lvf vf2 (&-> arg0 ys 2 quad))
|
|
(.sub.y.vf vf4 vf3 vf28)
|
|
(.mul.y.vf acc vf2 vf28)
|
|
(.add.mul.y.vf vf5 vf1 vf4 acc)
|
|
(b! #t cfg-5 :delay (.svf (&-> arg2 quad) vf5))
|
|
(label cfg-4)
|
|
(.lvf vf1 (&-> arg0 ys 2 quad))
|
|
(.lvf vf2 (&-> arg0 ys 3 quad))
|
|
(.sub.z.vf vf4 vf3 vf28)
|
|
(.mul.z.vf acc vf2 vf28)
|
|
(.add.mul.z.vf vf5 vf1 vf4 acc)
|
|
(.svf (&-> arg2 quad) vf5)
|
|
(label cfg-5)
|
|
arg2
|
|
)
|
|
)
|
|
|
|
;; definition for method 9 of type curve-color-fast
|
|
(defmethod evaluate ((this curve-color-fast) (arg0 float) (arg1 rgbaf) (arg2 loop-behavior))
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf1 :class vf)
|
|
(vf2 :class vf)
|
|
(vf23 :class vf)
|
|
(vf25 :class vf)
|
|
(vf26 :class vf)
|
|
(vf28 :class vf)
|
|
(vf3 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((v1-0 this)
|
|
(f0-0 arg0)
|
|
(a0-1 arg1)
|
|
)
|
|
(let ((a1-1 (new 'stack-no-clear 'rgbaf)))
|
|
(let ((a3-1 f0-0))
|
|
(.mov vf26 a3-1)
|
|
)
|
|
(.lvf vf23 (&-> v1-0 xs quad))
|
|
(.lvf vf25 (&-> v1-0 one-over-x-deltas quad))
|
|
(.max.w.vf vf3 vf0 vf0)
|
|
(.mul.vf acc vf25 vf23)
|
|
(.add.mul.x.vf vf28 vf25 vf26 acc)
|
|
(.svf (&-> a1-1 quad) vf28)
|
|
(let ((a3-2 (-> a1-1 z))
|
|
(a1-2 (-> a1-1 y))
|
|
)
|
|
(b! (>= (the-as int a3-2) 0) cfg-4 :delay (nop!))
|
|
(b! (>= (the-as int a1-2) 0) cfg-3 :delay (nop!))
|
|
)
|
|
)
|
|
(.lvf vf1 (&-> v1-0 ys 0 quad))
|
|
(.lvf vf2 (&-> v1-0 ys 1 quad))
|
|
(.sub.x.vf vf4 vf3 vf28)
|
|
(.mul.x.vf acc vf2 vf28)
|
|
(.add.mul.x.vf vf5 vf1 vf4 acc)
|
|
(b! #t cfg-5 :delay (.svf (&-> a0-1 quad) vf5))
|
|
(label cfg-3)
|
|
(.lvf vf1 (&-> v1-0 ys 1 quad))
|
|
(.lvf vf2 (&-> v1-0 ys 2 quad))
|
|
(.sub.y.vf vf4 vf3 vf28)
|
|
(.mul.y.vf acc vf2 vf28)
|
|
(.add.mul.y.vf vf5 vf1 vf4 acc)
|
|
(b! #t cfg-5 :delay (.svf (&-> a0-1 quad) vf5))
|
|
(label cfg-4)
|
|
(.lvf vf1 (&-> v1-0 ys 2 quad))
|
|
(.lvf vf2 (&-> v1-0 ys 3 quad))
|
|
(.sub.z.vf vf4 vf3 vf28)
|
|
(.mul.z.vf acc vf2 vf28)
|
|
(.add.mul.z.vf vf5 vf1 vf4 acc)
|
|
(.svf (&-> a0-1 quad) vf5)
|
|
)
|
|
(label cfg-5)
|
|
(set! (-> arg1 w) 1.0)
|
|
arg1
|
|
)
|
|
)
|
|
|
|
;; definition for function rgba<-rgbaf
|
|
(defun rgba<-rgbaf ((arg0 rgba) (arg1 rgbaf))
|
|
"Convert rgbaf to rgba. Seems like the input rgba's value is not used in any way."
|
|
(copy-and-set-field
|
|
(copy-and-set-field
|
|
(copy-and-set-field
|
|
(copy-and-set-field arg0 r (the int (* 128.0 (-> arg1 x))))
|
|
g
|
|
(the int (* 128.0 (-> arg1 y)))
|
|
)
|
|
b
|
|
(the int (* 128.0 (-> arg1 z)))
|
|
)
|
|
a
|
|
(the int (* 128.0 (-> arg1 w)))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! *curve-unity* (new 'static 'curve2d-fast
|
|
:xs (new 'static 'vector :data (new 'static 'array float 4 0.0 -1.0 -2.0 -3.0))
|
|
:ys (new 'static 'vector :data (new 'static 'array float 4 1.0 1.0 2.0 3.0))
|
|
:one-over-x-deltas (new 'static 'vector :data (new 'static 'array float 4 0.0 1.0 1.0 1.0))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! *curve-linear-up* (new 'static 'curve2d-fast
|
|
:xs (new 'static 'vector :data (new 'static 'array float 4 0.0 -1.0 -2.0 -3.0))
|
|
:ys (new 'static 'vector :data (new 'static 'array float 4 0.0 1.0 2.0 3.0))
|
|
:one-over-x-deltas (new 'static 'vector :data (new 'static 'array float 4 1.0 1.0 1.0 1.0))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! *curve-linear-down* (new 'static 'curve2d-fast
|
|
:xs (new 'static 'vector :data (new 'static 'array float 4 0.0 -1.0 -2.0 -3.0))
|
|
:ys (new 'static 'vector :data (new 'static 'array float 4 1.0 0.0 1.0 2.0))
|
|
:one-over-x-deltas (new 'static 'vector :data (new 'static 'array float 4 -1.0 1.0 1.0 1.0))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(when (or (zero? *curve-linear-up-hold*) (!= loading-level global))
|
|
(set! *curve-linear-up-hold* (new 'loading-level 'curve2d-piecewise))
|
|
(allocate! *curve-linear-up-hold* 2 'loading-level #f)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> *curve-linear-up-hold* pts data 0 first) 0.0)
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> *curve-linear-up-hold* pts data 0 second) 0.0)
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> *curve-linear-up-hold* pts data 1 first) 1.0)
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> *curve-linear-up-hold* pts data 1 second) 1.0)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! *curve-linear-up-down* (new 'static 'curve2d-fast
|
|
:xs (new 'static 'vector :data (new 'static 'array float 4 0.0 -0.5 -1.0 -2.0))
|
|
:ys (new 'static 'vector :data (new 'static 'array float 4 0.0 1.0 0.0 1.0))
|
|
:one-over-x-deltas (new 'static 'vector :data (new 'static 'array float 4 2.0 -2.0 1.0 1.0))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! *trail-color-curve-white*
|
|
(new 'static 'curve-color-fast
|
|
:xs (new 'static 'vector :data (new 'static 'array float 4 0.0 -1.0 -2.0 -3.0))
|
|
:ys (new 'static 'inline-array vector 4
|
|
(new 'static 'vector :data (new 'static 'array float 4 1.0 1.0 1.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 1.0 1.0 1.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 1.0 1.0 1.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 1.0 1.0 1.0 128.0))
|
|
)
|
|
:one-over-x-deltas (new 'static 'vector :data (new 'static 'array float 4 1.0 1.0 1.0 1.0))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! particle-color-curve-white*
|
|
(new 'static 'curve-color-fast
|
|
:xs (new 'static 'vector :data (new 'static 'array float 4 0.0 -1.0 -2.0 -3.0))
|
|
:ys (new 'static 'inline-array vector 4
|
|
(new 'static 'vector :data (new 'static 'array float 4 128.0 128.0 128.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 128.0 128.0 128.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 128.0 128.0 128.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 128.0 128.0 128.0 128.0))
|
|
)
|
|
:one-over-x-deltas (new 'static 'vector :data (new 'static 'array float 4 1.0 1.0 1.0 1.0))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! *trail-color-curve-red* (new 'static 'curve-color-fast
|
|
:xs (new 'static 'vector :data (new 'static 'array float 4 0.0 -0.2 -1.0 -2.0))
|
|
:ys (new 'static 'inline-array vector 4
|
|
(new 'static 'vector :data (new 'static 'array float 4 1.0 0.3 0.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 1.0 0.0 0.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 1.0 0.0 0.0 128.0))
|
|
(new 'static 'vector :data (new 'static 'array float 4 1.0 0.0 0.0 128.0))
|
|
)
|
|
:one-over-x-deltas (new 'static 'vector :data (new 'static 'array float 4 5.0 1.25 1.0 1.0))
|
|
)
|
|
)
|
|
)
|
|
|
|
|
|
|
|
|