mirror of
https://github.com/open-goal/jak-project
synced 2026-07-09 23:01:56 -04:00
water111
3856ae505a
They still don't work yet, this is just naming/comments to help with debug. The vehicle tracks are now at least trying to draw, but like the others, don't actually show up.
682 lines
22 KiB
Common Lisp
Vendored
Generated
682 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 loop-behavior)
|
|
)
|
|
(: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 loop-behavior)
|
|
)
|
|
(: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) (if arg2
|
|
(loop-behavior wrap)
|
|
(loop-behavior clamp)
|
|
)
|
|
)
|
|
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) (if arg2
|
|
(loop-behavior wrap)
|
|
(loop-behavior clamp)
|
|
)
|
|
)
|
|
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))
|
|
"Compute value of curve at the given position."
|
|
(when (or (< 1.0 arg0) (< arg0 0.0))
|
|
(if (= arg2 (loop-behavior use-default))
|
|
(set! arg2 (-> this default-loop-behavior))
|
|
)
|
|
(case arg2
|
|
(((loop-behavior wrap))
|
|
(set! arg0 (- arg0 (* (the float (the int (/ arg0 1.0))) 1.0)))
|
|
)
|
|
(((loop-behavior clamp))
|
|
(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))
|
|
"Compute value of curve at the given position."
|
|
(when (or (< 1.0 arg0) (< arg0 0.0))
|
|
(if (= arg1 (loop-behavior use-default))
|
|
(set! arg1 (-> this default-loop-behavior))
|
|
)
|
|
(case arg1
|
|
(((loop-behavior wrap))
|
|
(set! arg0 (- arg0 (* (the float (the int (/ arg0 1.0))) 1.0)))
|
|
)
|
|
(((loop-behavior clamp))
|
|
(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))
|
|
"Compute value of curve at the given position."
|
|
(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))
|
|
"Compute value of curve at the given position."
|
|
(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 :y -1.0 :z -2.0 :w -3.0)
|
|
:ys (new 'static 'vector :x 1.0 :y 1.0 :z 2.0 :w 3.0)
|
|
:one-over-x-deltas (new 'static 'vector :y 1.0 :z 1.0 :w 1.0)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! *curve-linear-up* (new 'static 'curve2d-fast
|
|
:xs (new 'static 'vector :y -1.0 :z -2.0 :w -3.0)
|
|
:ys (new 'static 'vector :y 1.0 :z 2.0 :w 3.0)
|
|
:one-over-x-deltas (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(if #t
|
|
(set! *curve-linear-down* (new 'static 'curve2d-fast
|
|
:xs (new 'static 'vector :y -1.0 :z -2.0 :w -3.0)
|
|
:ys (new 'static 'vector :x 1.0 :z 1.0 :w 2.0)
|
|
:one-over-x-deltas (new 'static 'vector :x -1.0 :y 1.0 :z 1.0 :w 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 :y -0.5 :z -1.0 :w -2.0)
|
|
:ys (new 'static 'vector :y 1.0 :w 1.0)
|
|
:one-over-x-deltas (new 'static 'vector :x 2.0 :y -2.0 :z 1.0 :w 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 :y -1.0 :z -2.0 :w -3.0)
|
|
:ys (new 'static 'inline-array vector 4
|
|
(new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 128.0)
|
|
(new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 128.0)
|
|
(new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 128.0)
|
|
(new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 128.0)
|
|
)
|
|
:one-over-x-deltas (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 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 :y -1.0 :z -2.0 :w -3.0)
|
|
:ys (new 'static 'inline-array vector 4
|
|
(new 'static 'vector :x 128.0 :y 128.0 :z 128.0 :w 128.0)
|
|
(new 'static 'vector :x 128.0 :y 128.0 :z 128.0 :w 128.0)
|
|
(new 'static 'vector :x 128.0 :y 128.0 :z 128.0 :w 128.0)
|
|
(new 'static 'vector :x 128.0 :y 128.0 :z 128.0 :w 128.0)
|
|
)
|
|
:one-over-x-deltas (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 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 :y -0.2 :z -1.0 :w -2.0)
|
|
:ys (new 'static 'inline-array vector 4
|
|
(new 'static 'vector :x 1.0 :y 0.3 :w 128.0)
|
|
(new 'static 'vector :x 1.0 :w 128.0)
|
|
(new 'static 'vector :x 1.0 :w 128.0)
|
|
(new 'static 'vector :x 1.0 :w 128.0)
|
|
)
|
|
:one-over-x-deltas (new 'static 'vector :x 5.0 :y 1.25 :z 1.0 :w 1.0)
|
|
)
|
|
)
|
|
)
|