mirror/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project synced 2026-05-25 15:25:31 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
66e395d547ff82a663a923279a94debe6cee1930
jak-project/test/decompiler/reference/engine/sparticle/sparticle-launcher_REF.gc
T
ManDude 0cdeed9be7 minor windows fixes (#1311) 
* [pp2] put `define` dest on a single line

* update source!

* Update type_analysis.cpp

* update old credits & racer code

* change clang-cl args (REALLY force avx)

* Update credits_REF.gc

* comment small unused code

* add timer to decompiler

* fix unnecessary copy-constructors (no speed increase)

* fixes

* Update expression_build.cpp

* wtf is this thing anyway

* im bored.

* clang

* fix!

* Revert "fix!"

This reverts commit 5b1ce6c718.

* Revert "clang"

This reverts commit 5e67d9ccd1.

* Revert "im bored."

This reverts commit 070e957ce8.

* Revert "Update expression_build.cpp"

This reverts commit b94d092fc5.

* Revert "fixes"

This reverts commit f3d871f60a.

* Revert "fix unnecessary copy-constructors (no speed increase)"

This reverts commit 9100725802.

* Keep the random inoffensive changes

* Revert "Update type_analysis.cpp"

This reverts commit d2456a5c75.

* Update type_analysis.cpp
2022-04-17 21:11:09 -04:00

1360 lines
47 KiB
Common Lisp
Vendored
Generated
Raw Blame History

;;-*-Lisp-*-
(in-package goal)
;; definition for symbol *particle-300hz-timer*, type int
(define *particle-300hz-timer* 0)
;; definition of type sparticle-birthinfo
(deftype sparticle-birthinfo (structure)
((sprite uint32 :offset-assert 0)
(anim int32 :offset-assert 4)
(anim-speed float :offset-assert 8)
(birth-func basic :offset-assert 12)
(joint-ppoint int32 :offset-assert 16)
(num-to-birth float :offset-assert 20)
(sound basic :offset-assert 24)
(dataf float 1 :offset 0)
(data uint32 1 :offset 0)
)
:method-count-assert 9
:size-assert #x1c
:flag-assert #x90000001c
)
;; definition for method 3 of type sparticle-birthinfo
(defmethod inspect sparticle-birthinfo ((obj sparticle-birthinfo))
(format #t "[~8x] ~A~%" obj 'sparticle-birthinfo)
(format #t "~Tsprite: ~D~%" (-> obj sprite))
(format #t "~Tanim: ~D~%" (-> obj anim))
(format #t "~Tanim-speed: ~f~%" (-> obj anim-speed))
(format #t "~Tbirth-func: ~A~%" (-> obj birth-func))
(format #t "~Tjoint-ppoint: ~D~%" (-> obj joint-ppoint))
(format #t "~Tnum-to-birth: ~f~%" (-> obj num-to-birth))
(format #t "~Tsound: ~A~%" (-> obj sound))
(format #t "~Tdataf[1] @ #x~X~%" (&-> obj sprite))
(format #t "~Tdata[1] @ #x~X~%" (&-> obj sprite))
obj
)
;; definition for method 3 of type sparticle-launcher
;; INFO: this function exists in multiple non-identical object files
;; INFO: Return type mismatch int vs sparticle-launcher.
(defmethod inspect sparticle-launcher ((obj sparticle-launcher))
(format #t "~X: sparticle-launcher~%" obj)
(let ((s5-0 0))
(while (!= (-> obj init-specs s5-0 field) (sp-field-id spt-end))
(let* ((v1-1 (-> obj init-specs s5-0))
(t9-1 format)
(a0-3 #t)
(a1-1 "~T~S : ~F / #x~X / ~D~%")
(a2-1 (-> v1-1 field))
)
(t9-1
a0-3
a1-1
(cond
((= a2-1 (sp-field-id spt-end))
"spt-end"
)
((= a2-1 (sp-field-id spt-scalevel))
"spt-scalevel"
)
((= a2-1 (sp-field-id spt-scale))
"spt-scale"
)
((= a2-1 (sp-field-id launch-fields-end))
"launch-fields-end"
)
((= a2-1 (sp-field-id spt-rotate-y))
"spt-rotate-y"
)
((= a2-1 (sp-field-id spt-conerot-radius))
"spt-conerot-radius"
)
((= a2-1 (sp-field-id spt-conerot-w))
"spt-conerot-w"
)
((= a2-1 (sp-field-id spt-conerot-z))
"spt-conerot-z"
)
((= a2-1 (sp-field-id spt-conerot-y))
"spt-conerot-y"
)
((= a2-1 (sp-field-id spt-conerot-x))
"spt-conerot-x"
)
((= a2-1 (sp-field-id spt-launchrot-w))
"spt-launchrot-w"
)
((= a2-1 (sp-field-id spt-launchrot-z))
"spt-launchrot-z"
)
((= a2-1 (sp-field-id spt-launchrot-y))
"spt-launchrot-y"
)
((= a2-1 (sp-field-id spt-launchrot-x))
"spt-launchrot-x"
)
((= a2-1 (sp-field-id launch-fields-start))
"launch-fields-start"
)
((= a2-1 (sp-field-id cpu-fields-end))
"cpu-fields-end"
)
((= a2-1 (sp-field-id spt-next-launcher))
"spt-next-launcher"
)
((= a2-1 (sp-field-id spt-next-time))
"spt-next-time"
)
((= a2-1 (sp-field-id spt-func))
"spt-func"
)
((= a2-1 (sp-field-id spt-userdata))
"spt-userdata"
)
((= a2-1 (sp-field-id spt-flags))
"spt-flags"
)
((= a2-1 (sp-field-id spt-timer))
"spt-timer"
)
((= a2-1 (sp-field-id spt-friction))
"spt-friction"
)
((= a2-1 (sp-field-id spt-quad-w))
"spt-quad-w"
)
((= a2-1 (sp-field-id spt-quat-z))
"spt-quat-z"
)
((= a2-1 (sp-field-id spt-quat-y))
"spt-quat-y"
)
((= a2-1 (sp-field-id spt-quat-x))
"spt-quat-x"
)
((= a2-1 (sp-field-id spt-dummy))
"spt-dummy"
)
((= a2-1 (sp-field-id spt-accel-z))
"spt-accel-z"
)
((= a2-1 (sp-field-id spt-accel-y))
"spt-accel-y"
)
((= a2-1 (sp-field-id spt-accel-x))
"spt-accel-x"
)
((= a2-1 (sp-field-id spt-fade-a))
"spt-fade-a"
)
((= a2-1 (sp-field-id spt-fade-b))
"spt-fade-b"
)
((= a2-1 (sp-field-id spt-fade-g))
"spt-fade-g"
)
((= a2-1 (sp-field-id spt-fade-r))
"spt-fade-r"
)
((= a2-1 (sp-field-id spt-scalevel-y))
"spt-scalevel-y"
)
((= a2-1 (sp-field-id spt-rotvel-z))
"spt-rotvel-z"
)
((= a2-1 (sp-field-id spt-rotvel-y))
"spt-rotvel-y"
)
((= a2-1 (sp-field-id spt-rotvel-x))
"spt-rotvel-x"
)
((= a2-1 (sp-field-id spt-scalevel-x))
"spt-scalevel-x"
)
((= a2-1 (sp-field-id spt-vel-z))
"spt-vel-z"
)
((= a2-1 (sp-field-id spt-vel-y))
"spt-vel-y"
)
((= a2-1 (sp-field-id spt-vel-x))
"spt-vel-x"
)
((= a2-1 (sp-field-id spt-omega))
"spt-omega"
)
((= a2-1 (sp-field-id cpu-fields-start))
"cpu-fields-start"
)
((= a2-1 (sp-field-id sprite-fields-end))
"sprite-fields-end"
)
((= a2-1 (sp-field-id spt-a))
"spt-a"
)
((= a2-1 (sp-field-id spt-b))
"spt-b"
)
((= a2-1 (sp-field-id spt-g))
"spt-g"
)
((= a2-1 (sp-field-id spt-r))
"spt-r"
)
((= a2-1 (sp-field-id spt-scale-y))
"spt-scale-y"
)
((= a2-1 (sp-field-id spt-rot-z))
"spt-rot-z"
)
((= a2-1 (sp-field-id spt-rot-y))
"spt-rot-y"
)
((= a2-1 (sp-field-id spt-rot-x))
"spt-rot-x"
)
((= a2-1 (sp-field-id spt-scale-x))
"spt-scale-x"
)
((= a2-1 (sp-field-id spt-z))
"spt-z"
)
((= a2-1 (sp-field-id spt-y))
"spt-y"
)
((= a2-1 (sp-field-id spt-x))
"spt-x"
)
((= a2-1 (sp-field-id sprite-fields-start))
"sprite-fields-start"
)
((= a2-1 (sp-field-id misc-fields-end))
"misc-fields-end"
)
((= a2-1 (sp-field-id spt-sound))
"spt-sound"
)
((= a2-1 (sp-field-id spt-num))
"spt-num"
)
((= a2-1 (sp-field-id spt-joint/refpoint))
"spt-joint/refpoint"
)
((= a2-1 (sp-field-id spt-birth-func))
"spt-birth-func"
)
((= a2-1 (sp-field-id spt-anim-speed))
"spt-anim-speed"
)
((= a2-1 (sp-field-id spt-anim))
"spt-anim"
)
((= a2-1 (sp-field-id spt-texture))
"spt-texture"
)
((= a2-1 (sp-field-id misc-fields-start))
"misc-fields-start"
)
(else
"*unknown*"
)
)
(-> v1-1 initial-valuef)
(-> v1-1 initial-valuef)
(-> v1-1 initial-valuef)
)
)
(+! s5-0 1)
)
)
(the-as sparticle-launcher 0)
)
;; definition for symbol *part-id-table*, type (array sparticle-launcher)
(define *part-id-table*
(the-as (array sparticle-launcher) (new 'global 'boxed-array sparticle-launcher 3584))
)
;; definition for symbol *part-group-id-table*, type (array sparticle-launch-group)
(define *part-group-id-table*
(the-as (array sparticle-launch-group) (new 'global 'boxed-array sparticle-launch-group 1024))
)
;; definition for function lookup-part-group-by-name
;; INFO: Return type mismatch sparticle-launch-group vs basic.
(defun lookup-part-group-by-name ((arg0 string))
(let* ((s5-0 *part-group-id-table*)
(s4-0 (-> s5-0 length))
)
(dotimes (s3-0 s4-0)
(let ((s2-0 (-> s5-0 s3-0)))
(if (and (nonzero? s2-0) (string= arg0 (-> s2-0 name)))
(return (the-as basic s2-0))
)
)
)
)
(the-as sparticle-launch-group #f)
)
;; definition for function lookup-part-group-pointer-by-name
(defun lookup-part-group-pointer-by-name ((arg0 string))
(let* ((s4-0 *part-group-id-table*)
(s3-0 (-> s4-0 length))
)
(dotimes (gp-0 s3-0)
(let ((v1-2 (-> s4-0 gp-0)))
(if (and (nonzero? v1-2) (string= arg0 (-> v1-2 name)))
(return (&+ (-> s4-0 data) (* gp-0 4)))
)
)
)
)
(the-as (pointer sparticle-launch-group) #f)
)
;; definition for function part-group-pointer?
(defun part-group-pointer? ((arg0 pointer))
(let ((v1-0 *part-group-id-table*))
(and (>= (the-as int arg0) (the-as int (-> v1-0 data))) (< (the-as int arg0) (the-as int (&-> v1-0 1024))))
)
)
;; definition for function unlink-part-group-by-heap
(defun unlink-part-group-by-heap ((arg0 kheap))
(let* ((v1-0 *part-group-id-table*)
(a2-0 (-> v1-0 length))
(a1-0 (-> arg0 base))
(a0-1 (-> arg0 top-base))
)
(while (nonzero? a2-0)
(+! a2-0 -1)
(let ((a3-2 (-> v1-0 a2-0)))
(when (and (>= (the-as int a3-2) (the-as int a1-0)) (< (the-as int a3-2) (the-as int a0-1)))
(set! (-> v1-0 a2-0) (the-as sparticle-launch-group 0))
0
)
)
)
)
0
)
;; definition for function sp-init-fields!
;; ERROR: function was not converted to expressions. Cannot decompile.
;; definition of type sp-queued-launch-particles
(deftype sp-queued-launch-particles (structure)
((sp-system sparticle-system :offset-assert 0)
(sp-launcher sparticle-launcher :offset-assert 4)
(pos vector :inline :offset-assert 16)
)
:method-count-assert 9
:size-assert #x20
:flag-assert #x900000020
)
;; definition for method 3 of type sp-queued-launch-particles
(defmethod inspect sp-queued-launch-particles ((obj sp-queued-launch-particles))
(format #t "[~8x] ~A~%" obj 'sp-queued-launch-particles)
(format #t "~Tsp-system: ~A~%" (-> obj sp-system))
(format #t "~Tsp-launcher: ~A~%" (-> obj sp-launcher))
(format #t "~Tpos: #<vector @ #x~X>~%" (-> obj pos))
obj
)
;; definition of type sp-launch-queue
(deftype sp-launch-queue (basic)
((in-use int32 :offset-assert 4)
(queue sp-queued-launch-particles 32 :inline :offset-assert 16)
)
:method-count-assert 9
:size-assert #x410
:flag-assert #x900000410
)
;; definition for method 3 of type sp-launch-queue
(defmethod inspect sp-launch-queue ((obj sp-launch-queue))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tin-use: ~D~%" (-> obj in-use))
(format #t "~Tqueue[32] @ #x~X~%" (-> obj queue))
obj
)
;; definition for symbol *sp-launcher-lock*, type symbol
(define *sp-launcher-lock* #f)
;; definition for symbol *sp-launch-queue*, type sp-launch-queue
(define *sp-launch-queue* (new 'global 'sp-launch-queue))
;; definition for symbol *sp-launcher-enable*, type symbol
(define *sp-launcher-enable* #t)
;; definition for function particle-setup-adgif
;; INFO: Return type mismatch int vs none.
(defun particle-setup-adgif ((arg0 adgif-shader) (arg1 texture-id))
(let ((a1-1 (lookup-texture-by-id arg1)))
(set! (-> arg0 tex1) (new 'static 'gs-tex1 :mmag #x1 :mmin #x1))
(set! (-> arg0 tex0 tfx) 0)
(if a1-1
(adgif-shader<-texture! arg0 a1-1)
)
)
(set! (-> arg0 prims 1) (gs-reg64 tex0-1))
(set! (-> arg0 prims 3) (gs-reg64 tex1-1))
(set! (-> arg0 prims 5) (gs-reg64 miptbp1-1))
(set! (-> arg0 clamp-reg) (gs-reg64 zbuf-1))
(set! (-> arg0 prims 9) (gs-reg64 alpha-1))
(set! (-> arg0 alpha) (new 'static 'gs-alpha :b #x1 :d #x1))
(set! (-> arg0 clamp) (new 'static 'gs-clamp :minu #x1c :minv #x101))
0
(none)
)
;; definition of type particle-adgif-cache
(deftype particle-adgif-cache (basic)
((used int32 :offset-assert 4)
(last uint16 :offset-assert 8)
(lastgif adgif-shader :offset-assert 12)
(tidhash uint16 80 :offset-assert 16)
(spadgif adgif-shader 80 :inline :offset-assert 176)
)
:method-count-assert 9
:size-assert #x19b0
:flag-assert #x9000019b0
)
;; definition for method 3 of type particle-adgif-cache
(defmethod inspect particle-adgif-cache ((obj particle-adgif-cache))
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~Tused: ~D~%" (-> obj used))
(format #t "~Tlast: ~D~%" (-> obj last))
(format #t "~Tlastgif: #<adgif-shader @ #x~X>~%" (-> obj lastgif))
(format #t "~Ttidhash[80] @ #x~X~%" (-> obj tidhash))
(format #t "~Tspadgif[80] @ #x~X~%" (-> obj spadgif))
obj
)
;; definition for symbol *particle-adgif-cache*, type particle-adgif-cache
(define *particle-adgif-cache* (new 'global 'particle-adgif-cache))
;; failed to figure out what this is:
(set! (-> *particle-adgif-cache* used) 0)
;; definition for function particle-adgif
;; ERROR: function was not converted to expressions. Cannot decompile.
;; definition for function sp-queue-launch
;; Used lq/sq
(defun sp-queue-launch ((arg0 sparticle-system) (arg1 sparticle-launcher) (arg2 vector))
(let ((v1-0 *sp-launch-queue*))
(when (= (-> v1-0 in-use) 32)
(format 0 "ERROR: sp-launch-particles called during processing, and queue is full~%")
(return 0)
)
(let ((a3-5 (-> v1-0 queue (-> v1-0 in-use))))
(set! (-> a3-5 sp-system) arg0)
(set! (-> a3-5 sp-launcher) arg1)
(set! (-> a3-5 pos quad) (-> arg2 quad))
)
(let ((v0-1 (+ (-> v1-0 in-use) 1)))
(set! (-> v1-0 in-use) v0-1)
v0-1
)
)
)
;; definition for function sp-adjust-launch
;; INFO: Return type mismatch int vs none.
(defun sp-adjust-launch ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo) (arg2 (inline-array sp-field-init-spec)))
(let ((s5-0 (new 'stack-no-clear 'sparticle-launchinfo)))
(let ((s2-0 (new 'stack-no-clear 'matrix))
(s3-0 (new 'stack-no-clear 'vector))
)
(sp-init-fields!
(-> s5-0 launchrot)
arg2
(sp-field-id launch-fields-start)
(sp-field-id launch-fields-end)
#t
)
(matrix-rotate-xyz! s2-0 (-> s5-0 launchrot))
(vector3s-matrix*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s2-0)
(matrix-rotate-xyz! s2-0 (-> s5-0 conerot))
(vector3s-matrix*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s2-0)
(if (logtest? (sp-cpuinfo-flag launch-along-z) (-> arg1 flags))
(set-vector! s3-0 0.0 0.0 (-> s5-0 coneradius) 1.0)
(set-vector! s3-0 0.0 (-> s5-0 coneradius) 0.0 1.0)
)
(vector-matrix*! s3-0 s3-0 s2-0)
(+! (-> arg0 launchrot x) (-> s3-0 x))
(+! (-> arg0 launchrot y) (-> s3-0 y))
(+! (-> arg0 launchrot z) (-> s3-0 z))
)
(when (!= (-> s5-0 rotate-y) 0.0)
(let ((s3-1 (new 'stack-no-clear 'matrix)))
(matrix-rotate-y! s3-1 (-> s5-0 rotate-y))
(vector3s-rotate*! (the-as vector3s (-> arg0 launchrot)) (the-as vector3s (-> arg0 launchrot)) s3-1)
(vector3s-rotate*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s3-1)
(if (zero? (logand (sp-cpuinfo-flag use-global-acc) (-> arg1 flags)))
(vector3s-rotate*! (the-as vector3s (-> arg1 acc)) (the-as vector3s (-> arg1 acc)) s3-1)
)
)
(if (logtest? (sp-cpuinfo-flag set-conerot) (-> arg1 flags))
(set! (-> arg0 conerot y) (+ 16384.0 (-> s5-0 rotate-y)))
)
)
)
0
(none)
)
;; definition for function sp-euler-convert
;; INFO: Return type mismatch int vs none.
(defun sp-euler-convert ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo))
(local-vars (v1-1 float) (v1-2 float))
(rlet ((vf0 :class vf)
(vf1 :class vf)
(vf2 :class vf)
)
(init-vf0-vector)
(let ((a1-1 (new 'stack-no-clear 'vector))
(s5-0 (new 'stack-no-clear 'quaternion))
)
(set-vector! a1-1 (-> arg0 conerot x) (-> arg0 conerot y) (-> arg0 conerot z) 1.0)
(quaternion-zxy! s5-0 a1-1)
(cond
((< (-> s5-0 w) 0.0)
(.lvf vf1 (&-> arg0 conerot quad))
(.lvf vf2 (&-> s5-0 vec quad))
(.sub.vf vf1 vf0 vf2 :mask #b111)
(.svf (&-> arg0 conerot quad) vf1)
(.mov v1-1 vf1)
)
(else
(.lvf vf1 (&-> arg0 conerot quad))
(.lvf vf2 (&-> s5-0 vec quad))
(.add.vf vf1 vf0 vf2 :mask #b111)
(.svf (&-> arg0 conerot quad) vf1)
(.mov v1-2 vf1)
)
)
)
(cond
(*sp-60-hz*
(set! (-> arg1 rot-syvel x) (* 5.0 (-> arg1 rot-syvel x)))
(set! (-> arg1 rot-syvel y) (* 5.0 (-> arg1 rot-syvel y)))
(set! (-> arg1 rot-syvel z) (* 5.0 (-> arg1 rot-syvel z)))
)
(else
(set! (-> arg1 rot-syvel x) (* 6.0 (-> arg1 rot-syvel x)))
(set! (-> arg1 rot-syvel y) (* 6.0 (-> arg1 rot-syvel y)))
(set! (-> arg1 rot-syvel z) (* 6.0 (-> arg1 rot-syvel z)))
)
)
(quaternion-zxy! (-> arg1 rotvel3d) (-> arg1 rot-syvel))
0
(none)
)
)
;; definition for function sp-rotate-system
;; INFO: Return type mismatch int vs none.
(defun sp-rotate-system ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo) (arg2 transformq))
(let ((s5-0 (new 'stack-no-clear 'matrix)))
(let ((a1-1 (new 'stack-no-clear 'quaternion)))
(let* ((v1-0 a1-1)
(a0-1 arg2)
(f0-0 (-> a0-1 quat x))
(f1-0 (-> a0-1 quat y))
(f3-0 (-> a0-1 quat z))
)
(set! (-> v1-0 x) f0-0)
(set! (-> v1-0 y) f1-0)
(set! (-> v1-0 z) f3-0)
(set! (-> v1-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0))))
)
(quaternion->matrix s5-0 a1-1)
)
(vector3s-rotate*! (the-as vector3s (-> arg0 launchrot)) (the-as vector3s (-> arg0 launchrot)) s5-0)
(vector3s-rotate*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s5-0)
(if (zero? (logand (sp-cpuinfo-flag use-global-acc) (-> arg1 flags)))
(vector3s-rotate*! (the-as vector3s (-> arg1 acc)) (the-as vector3s (-> arg1 acc)) s5-0)
)
)
0
(none)
)
;; definition for function sp-launch-particles-var
;; ERROR: function was not converted to expressions. Cannot decompile.
;; definition for symbol *death-adgif*, type adgif-shader
(define *death-adgif* (the-as adgif-shader #f))
;; definition for function sp-launch-particles-death
;; INFO: Return type mismatch int vs none.
;; WARN: Expression building failed: Function sp-launch-particles-death has a return type of none, but the expression builder found a return statement.
;; Used lq/sq
(defun sp-launch-particles-death ((arg0 sparticle-system) (arg1 sparticle-launcher) (arg2 vector))
(local-vars (v1-25 float) (v1-27 float))
(rlet ((vf0 :class vf)
(vf1 :class vf)
(vf2 :class vf)
(vf3 :class vf)
(vf30 :class vf)
(vf31 :class vf)
(vf4 :class vf)
(vf5 :class vf)
(vf6 :class vf)
)
(init-vf0-vector)
(.lvf vf30 (&-> arg2 quad))
(let ((v1-0 #x437f0000))
(.mov vf31 v1-0)
)
(let ((s5-0 (new 'stack-no-clear 'sprite-vec-data-2d))
(gp-0 (sp-get-particle arg0 0 (the-as sparticle-launch-state #f)))
)
(if (not gp-0)
(return 0)
)
(let* ((a1-2 (-> arg1 init-specs 0))
(a1-3
(sp-init-fields!
(&-> s5-0 x)
(the-as (inline-array sp-field-init-spec) a1-2)
(sp-field-id sprite-fields-start)
(sp-field-id sprite-fields-end)
#t
)
)
)
(sp-init-fields!
(&-> gp-0 omega)
(the-as (inline-array sp-field-init-spec) a1-3)
(sp-field-id cpu-fields-start)
(sp-field-id cpu-fields-end)
#t
)
)
(set! (-> s5-0 matrix) 0)
(set! (-> s5-0 rot) (the float (sar (shl (the int (-> s5-0 rot)) 48) 48)))
(.lvf vf4 (&-> s5-0 color quad))
(.lvf vf5 (&-> s5-0 x-y-z-sx quad))
(.min.x.vf vf4 vf4 vf31 :mask #b111)
(.add.vf vf5 vf5 vf30 :mask #b111)
(.svf (&-> s5-0 color quad) vf4)
(.svf (&-> s5-0 x-y-z-sx quad) vf5)
(when (not *death-adgif*)
(set! *death-adgif* (new 'static 'adgif-shader))
(particle-adgif *death-adgif* (new 'static 'texture-id :index #x18 :page #x2))
(set! (-> *death-adgif* alpha) (new 'static 'gs-alpha :b #x2 :d #x1))
)
(let ((v1-14 (-> *death-adgif* quad 0 quad)))
(set! (-> gp-0 adgif quad 0 quad) v1-14)
)
(let ((v1-16 (-> *death-adgif* quad 1 quad)))
(set! (-> gp-0 adgif quad 1 quad) v1-16)
)
(let ((v1-18 (-> *death-adgif* quad 2 quad)))
(set! (-> gp-0 adgif quad 2 quad) v1-18)
)
(let ((v1-20 (-> *death-adgif* quad 3 quad)))
(set! (-> gp-0 adgif quad 3 quad) v1-20)
)
(let ((v1-22 (-> *death-adgif* quad 4 quad)))
(set! (-> gp-0 adgif quad 4 quad) v1-22)
)
(.lvf vf4 (&-> (-> *time-of-day-context* current-prt-color) quad))
(.lvf vf5 (&-> s5-0 color quad))
(.lvf vf6 (&-> gp-0 fade quad))
(.mul.vf vf5 vf5 vf4 :mask #b111)
(.mul.vf vf6 vf6 vf4 :mask #b111)
(.svf (&-> s5-0 color quad) vf5)
(.svf (&-> gp-0 fade quad) vf6)
(.mov v1-25 vf6)
(set! (-> gp-0 key) (the-as sparticle-launch-control 0))
(set! (-> gp-0 binding) #f)
(let ((v1-26 (-> gp-0 sprite)))
(.lvf vf1 (&-> s5-0 x-y-z-sx quad))
(.lvf vf2 (&-> s5-0 flag-rot-sy quad))
(.lvf vf3 (&-> s5-0 color quad))
(.svf (&-> v1-26 x-y-z-sx quad) vf1)
(.svf (&-> v1-26 flag-rot-sy quad) vf2)
(.sub.w.vf vf3 vf0 vf0 :mask #b1000)
(.svf (&-> v1-26 color quad) vf3)
)
(.mov v1-27 vf3)
(logior! (-> gp-0 flags) (sp-cpuinfo-flag ready-to-launch))
(set! (-> gp-0 cache-alpha) (-> s5-0 a))
)
0
(none)
)
)
;; definition for function sp-clear-queue
;; INFO: Return type mismatch int vs none.
(defun sp-clear-queue ()
(let ((gp-0 *sp-launch-queue*))
(when (> (-> gp-0 in-use) 0)
(dotimes (s5-0 (-> gp-0 in-use))
(let ((v1-4 (-> gp-0 queue s5-0)))
(sp-launch-particles-var
(-> v1-4 sp-system)
(-> v1-4 sp-launcher)
(-> v1-4 pos)
(the-as sparticle-launch-state #f)
(the-as sparticle-launch-control #f)
1.0
)
)
)
(set! (-> gp-0 in-use) 0)
0
)
)
0
(none)
)
;; definition for function sp-relaunch-setup-fields
;; INFO: Return type mismatch int vs none.
(defun sp-relaunch-setup-fields ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d))
(let ((a1-1 (-> arg1 init-specs 0))
(s4-0 (logand (-> arg2 flags) (sp-cpuinfo-flag level0 level1)))
)
(set! (-> arg2 next-launcher) (the-as basic 0))
(cond
((and (logtest? (-> arg2 flags) (sp-cpuinfo-flag bit12))
(zero? (logand (-> arg2 flags) (sp-cpuinfo-flag aux-list)))
)
(let ((f20-0 (-> arg3 r-g-b-a x))
(f22-0 (-> arg3 r-g-b-a y))
(f24-0 (-> arg3 r-g-b-a z))
(f26-0 (-> arg2 fade x))
(f28-0 (-> arg2 fade y))
(f30-0 (-> arg2 fade z))
)
(set! (-> arg3 r-g-b-a x) 99999.0)
(set! (-> arg3 r-g-b-a y) 99999.0)
(set! (-> arg3 r-g-b-a z) 99999.0)
(set! (-> arg2 fade x) 99999.0)
(set! (-> arg2 fade y) 99999.0)
(set! (-> arg2 fade z) 99999.0)
(let ((a1-2
(sp-init-fields!
(-> arg3 x-y-z-sx)
(the-as (inline-array sp-field-init-spec) a1-1)
(sp-field-id sprite-fields-start)
(sp-field-id sprite-fields-end)
#f
)
)
)
(sp-init-fields!
(&-> arg2 omega)
(the-as (inline-array sp-field-init-spec) a1-2)
(sp-field-id cpu-fields-start)
(sp-field-id cpu-fields-end)
#f
)
)
(logior! (-> arg2 flags) s4-0)
(if (logtest? (-> arg2 flags) (sp-cpuinfo-flag level1))
(-> *level* level1)
(-> *level* level0)
)
(let ((v1-16 (-> *time-of-day-context* current-prt-color)))
(if (= (-> arg3 r-g-b-a x) 99999.0)
(set! (-> arg3 r-g-b-a x) f20-0)
(set! (-> arg3 r-g-b-a x) (* (-> arg3 r-g-b-a x) (-> v1-16 x)))
)
(if (= (-> arg3 r-g-b-a y) 99999.0)
(set! (-> arg3 r-g-b-a y) f22-0)
(set! (-> arg3 r-g-b-a y) (* (-> arg3 r-g-b-a y) (-> v1-16 y)))
)
(if (= (-> arg3 r-g-b-a z) 99999.0)
(set! (-> arg3 r-g-b-a z) f24-0)
(set! (-> arg3 r-g-b-a z) (* (-> arg3 r-g-b-a z) (-> v1-16 z)))
)
(if (= (-> arg2 fade x) 99999.0)
(set! (-> arg2 fade x) f26-0)
(set! (-> arg2 fade x) (* (-> arg2 fade x) (-> v1-16 x)))
)
(if (= (-> arg2 fade y) 99999.0)
(set! (-> arg2 fade y) f28-0)
(set! (-> arg2 fade y) (* (-> arg2 fade y) (-> v1-16 y)))
)
(if (= (-> arg2 fade z) 99999.0)
(set! (-> arg2 fade z) f30-0)
(set! (-> arg2 fade z) (* (-> arg2 fade z) (-> v1-16 z)))
)
)
)
)
(else
(let ((a1-3
(sp-init-fields!
(-> arg3 x-y-z-sx)
(the-as (inline-array sp-field-init-spec) a1-1)
(sp-field-id sprite-fields-start)
(sp-field-id sprite-fields-end)
#f
)
)
)
(sp-init-fields!
(&-> arg2 omega)
(the-as (inline-array sp-field-init-spec) a1-3)
(sp-field-id cpu-fields-start)
(sp-field-id cpu-fields-end)
#f
)
)
)
)
)
0
0
(none)
)
;; definition for function sp-relaunch-particle-2d
;; INFO: Return type mismatch int vs none.
(defun sp-relaunch-particle-2d ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d))
(sp-relaunch-setup-fields arg0 arg1 arg2 arg3)
(when (logtest? (-> arg2 flags) (sp-cpuinfo-flag aux-list))
(set! (-> arg2 func) add-to-sprite-aux-list)
(set! (-> arg3 r-g-b-a w) 0.0)
(set! (-> arg2 fade w) 0.0)
(logclear! (-> arg2 flags) (sp-cpuinfo-flag bit2))
)
0
(none)
)
;; definition for function sp-relaunch-particle-3d
;; INFO: Return type mismatch int vs none.
(defun sp-relaunch-particle-3d ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d))
(local-vars (v1-9 float) (v1-10 float))
(rlet ((vf0 :class vf)
(vf1 :class vf)
(vf2 :class vf)
)
(init-vf0-vector)
(let ((s4-0 (new 'stack-no-clear 'quaternion)))
(let* ((v1-0 s4-0)
(a2-1 arg3)
(f0-0 (-> a2-1 qx-qy-qz-sy x))
(f1-0 (-> a2-1 qx-qy-qz-sy y))
(f3-0 (-> a2-1 qx-qy-qz-sy z))
)
(set! (-> v1-0 x) f0-0)
(set! (-> v1-0 y) f1-0)
(set! (-> v1-0 z) f3-0)
(set! (-> v1-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0))))
)
(set! (-> arg3 qx-qy-qz-sy x) 0.0)
(set! (-> arg3 qx-qy-qz-sy y) 0.0)
(set! (-> arg3 qx-qy-qz-sy z) 0.0)
(sp-relaunch-setup-fields arg0 arg1 arg2 arg3)
(let ((a1-1 (new 'stack-no-clear 'vector))
(s3-0 (new 'stack-no-clear 'quaternion))
)
(set-vector! a1-1 (-> arg3 qx-qy-qz-sy x) (-> arg3 qx-qy-qz-sy y) (-> arg3 qx-qy-qz-sy z) 1.0)
(quaternion-zxy! s3-0 a1-1)
(cond
((logtest? (sp-cpuinfo-flag left-multiply-quat) (-> arg2 flags))
(quaternion*! s3-0 s4-0 s3-0)
)
(else
(if (logtest? (sp-cpuinfo-flag right-multiply-quat) (-> arg2 flags))
(quaternion*! s3-0 s3-0 s4-0)
)
)
)
(cond
((< (-> s3-0 w) 0.0)
(.lvf vf1 (&-> arg3 qx-qy-qz-sy quad))
(.lvf vf2 (&-> s3-0 vec quad))
(.sub.vf vf1 vf0 vf2 :mask #b111)
(.svf (&-> arg3 qx-qy-qz-sy quad) vf1)
(.mov v1-9 vf1)
)
(else
(.lvf vf1 (&-> arg3 qx-qy-qz-sy quad))
(.lvf vf2 (&-> s3-0 vec quad))
(.add.vf vf1 vf0 vf2 :mask #b111)
(.svf (&-> arg3 qx-qy-qz-sy quad) vf1)
(.mov v1-10 vf1)
)
)
)
)
(cond
(*sp-60-hz*
(set! (-> arg2 rot-syvel x) (* 5.0 (-> arg2 rot-syvel x)))
(set! (-> arg2 rot-syvel y) (* 5.0 (-> arg2 rot-syvel y)))
(set! (-> arg2 rot-syvel z) (* 5.0 (-> arg2 rot-syvel z)))
)
(else
(set! (-> arg2 rot-syvel x) (* 6.0 (-> arg2 rot-syvel x)))
(set! (-> arg2 rot-syvel y) (* 6.0 (-> arg2 rot-syvel y)))
(set! (-> arg2 rot-syvel z) (* 6.0 (-> arg2 rot-syvel z)))
)
)
(quaternion-zxy! (-> arg2 rotvel3d) (-> arg2 rot-syvel))
0
(none)
)
)
;; definition for method 9 of type sparticle-launch-control
;; INFO: Return type mismatch int vs none.
(defmethod initialize sparticle-launch-control ((obj sparticle-launch-control) (arg0 sparticle-launch-group) (arg1 process))
(let ((s5-0 0))
(set! (-> obj group) arg0)
(set! (-> obj proc) arg1)
(set! (-> obj local-clock) 0)
(set! (-> obj fade) 1.0)
(set! (-> obj matrix) 0)
(set! (-> obj last-spawn-frame)
(the-as int (+ (-> *display* real-actual-frame-counter) (seconds -0.006666667)))
)
(set! (-> obj last-spawn-time) 0)
(dotimes (s3-0 (-> arg0 length))
(let* ((a0-2 (-> arg0 launcher s3-0))
(a1-2 (-> *part-id-table* (-> a0-2 launcher)))
(v1-9 (-> obj data s5-0))
)
(when (nonzero? a1-2)
(set! (-> v1-9 group-item) a0-2)
(cond
((= (-> a1-2 type) sparticle-launcher)
(set! (-> v1-9 accum) 0.0)
(set! (-> v1-9 spawn-time) (the-as uint (+ *particle-300hz-timer* -30000)))
(set! (-> v1-9 offset) (-> a0-2 offset))
(set! (-> v1-9 randomize) (the-as uint 0))
(cond
((logtest? (-> a0-2 flags) (sp-group-item-flag start-dead))
(logclear! (-> v1-9 flags) (sp-launch-state-flags launcher-active))
(set! (-> v1-9 origin) #f)
(set! (-> v1-9 sprite3d) #f)
(set! (-> v1-9 sprite) #f)
)
(else
(logior! (-> v1-9 flags) (sp-launch-state-flags launcher-active))
(set! (-> v1-9 origin) (-> obj center))
(set! (-> v1-9 sprite3d) #f)
(set! (-> v1-9 sprite) #f)
)
)
(+! s5-0 1)
)
(else
(format 0 "initialize called with non-particle-launcher~%")
)
)
)
)
)
(set! (-> obj length) s5-0)
)
0
(none)
)
;; definition for method 9 of type sparticle-launch-group
;; INFO: Return type mismatch object vs sparticle-launch-control.
(defmethod create-launch-control sparticle-launch-group ((obj sparticle-launch-group) (arg0 process))
(let ((gp-0 (the-as object (new 'process 'sparticle-launch-control (-> obj length)))))
(when (zero? (the-as sparticle-launch-control gp-0))
(go process-drawable-art-error "memory")
(set! gp-0 0)
(goto cfg-4)
)
(initialize (the-as sparticle-launch-control gp-0) obj arg0)
(label cfg-4)
(the-as sparticle-launch-control gp-0)
)
)
;; definition for method 12 of type sparticle-launch-control
;; INFO: Return type mismatch int vs none.
(defmethod kill-and-free-particles sparticle-launch-control ((obj sparticle-launch-control))
(countdown (v1-0 (-> obj length))
(let ((a0-3 (-> obj data v1-0)))
(logclear! (-> a0-3 flags) (sp-launch-state-flags particles-active))
)
)
(set! (-> obj local-clock) 0)
(set! (-> obj fade) 1.0)
(kill-all-particles-with-key obj)
(if (> (-> obj matrix) 0)
(sprite-release-user-hvdf (-> obj matrix))
)
0
(none)
)
;; definition for method 13 of type sparticle-launch-control
;; INFO: Return type mismatch int vs none.
(defmethod kill-particles sparticle-launch-control ((obj sparticle-launch-control))
(kill-all-particles-with-key obj)
0
(none)
)
;; definition for method 10 of type sparticle-launch-control
(defmethod is-visible? sparticle-launch-control ((obj sparticle-launch-control) (arg0 vector))
(let* ((v1-0 (-> obj group))
(f0-0 (-> v1-0 bounds w))
)
(cond
((= f0-0 0.0)
#t
)
((nonzero? (-> obj matrix))
#t
)
(else
(let ((gp-1 (vector+! (new 'stack-no-clear 'vector) arg0 (the-as vector (-> v1-0 bounds)))))
(set! (-> gp-1 w) f0-0)
(if (and *display-actor-vis* (or (not *display-actor-anim*) (name= *display-actor-anim* (-> obj proc name))))
(add-debug-sphere
*display-actor-vis*
(bucket-id debug-draw0)
gp-1
(-> gp-1 w)
(new 'static 'rgba :g #xff :a #x80)
)
)
(sphere-in-view-frustum? (the-as sphere gp-1))
)
)
)
)
)
;; definition for method 11 of type sparticle-launch-control
;; INFO: Return type mismatch int vs object.
;; Used lq/sq
(defmethod spawn sparticle-launch-control ((obj sparticle-launch-control) (arg0 vector))
(set! (-> obj center quad) (-> arg0 quad))
(if (not (or (is-visible? obj arg0) (logtest? (-> obj group flags) (sp-group-flag always-draw screen-space))))
(return (the-as object 0))
)
(let ((s4-0 *particle-300hz-timer*)
(s5-0 (-> obj last-spawn-time))
)
(let ((v1-8 (-> *display* real-actual-frame-counter)))
(if (!= v1-8 (+ (-> obj last-spawn-frame) 1))
(set! s5-0 (- s4-0 (logand (the-as int (-> *sp-frame-time* x)) 255)))
)
)
(set! (-> obj last-spawn-frame) (the-as int (-> *display* real-actual-frame-counter)))
(set! (-> obj last-spawn-time) s4-0)
(when (logtest? (-> obj group flags) (sp-group-flag use-local-clock))
(set! s5-0 (-> obj local-clock))
(+! (-> obj local-clock) (logand (the-as int (-> *sp-frame-time* x)) 255))
(set! s4-0 (-> obj local-clock))
)
(let ((f30-0 (vector-vector-distance arg0 (math-camera-pos)))
(s3-1 (ash 1 (if *time-of-day-proc*
(-> *time-of-day-proc* 0 hour)
0
)
)
)
)
(if (nonzero? (-> obj matrix))
(set! f30-0 0.0)
)
(let ((s2-1 (-> obj length)))
(while (begin (label cfg-79) (nonzero? s2-1))
(+! s2-1 -1)
(let* ((a3-0 (-> obj data s2-1))
(v1-29 (-> a3-0 group-item))
(a1-4 (-> *part-id-table* (-> v1-29 launcher)))
)
(when (and a1-4 (nonzero? a1-4) (logtest? (-> a3-0 flags) (sp-launch-state-flags launcher-active)))
(let ((f0-2 1.0))
(if (!= (-> v1-29 falloff-to) 0.0)
(set! f0-2 (- 1.0 (/ f30-0 (-> v1-29 falloff-to))))
)
(let ((a0-26 sparticle-launcher))
(b! (!= (-> a1-4 type) a0-26) cfg-78 :delay (nop!))
)
(b! (zero? (logand (-> v1-29 flags) (sp-group-item-flag launch-asap))) cfg-36 :delay (nop!))
(when (zero? (logand (-> a3-0 flags) (sp-launch-state-flags particles-active)))
(set! (-> a3-0 spawn-time) (the-as uint s4-0))
(logior! (-> a3-0 flags) (sp-launch-state-flags particles-active))
(if (< 0.0 f0-2)
(sp-launch-particles-var
(if (logtest? (-> v1-29 flags) (sp-group-item-flag is-3d))
*sp-particle-system-3d*
*sp-particle-system-2d*
)
a1-4
(-> a3-0 origin)
a3-0
obj
f0-2
)
)
)
(b! #t cfg-77 :delay (nop!))
(label cfg-36)
(when (logtest? s3-1 (-> v1-29 hour-mask))
0
(goto cfg-77)
)
(when (not (or (= (-> v1-29 fade-after) 0.0) (< f30-0 (-> v1-29 fade-after))))
0
(b! #t cfg-77 :delay (nop!))
(set! v1-29 (the-as sparticle-group-item 0))
)
(b! (nonzero? (-> v1-29 period)) cfg-50 :delay (empty-form))
(let ((f0-4 (* 0.2 (the float (- s4-0 s5-0)) f0-2)))
(b! #t cfg-72 :delay (nop!))
(label cfg-50)
(let ((a2-5 (mod (+ s5-0 (-> obj data s2-1 offset)) (the-as int (-> v1-29 period))))
(a0-56 (mod (the-as uint (+ s4-0 (-> obj data s2-1 offset))) (-> v1-29 period)))
(t0-2 (-> v1-29 length))
)
(set! f0-4 (cond
((and (< a2-5 (the-as int t0-2)) (< a0-56 t0-2))
(* 0.2 (the float (- s4-0 s5-0)) f0-2)
)
((and (< a2-5 (the-as int t0-2)) (>= a0-56 t0-2))
(* 0.2 (the float (- t0-2 (the-as uint a2-5))) f0-2)
)
((and (>= a2-5 (the-as int t0-2)) (< a0-56 t0-2))
(* 0.2 (the float a0-56) f0-2)
)
(else
(when (zero? (logand (-> v1-29 flags) (sp-group-item-flag bit1)))
0
(goto cfg-77)
)
(when (< (the-as uint (- s4-0 (the-as int (-> obj data s2-1 spawn-time)))) (-> v1-29 period))
0
(goto cfg-77)
)
(set! (-> obj data s2-1 offset) (- (-> v1-29 period) a0-56))
(* 0.2 (the float (- s4-0 s5-0)) f0-2)
)
)
)
)
(label cfg-72)
(set! (-> a3-0 spawn-time) (the-as uint s4-0))
(logior! (-> a3-0 flags) (sp-launch-state-flags particles-active))
(if (< 0.0 f0-4)
(sp-launch-particles-var
(if (logtest? (-> v1-29 flags) (sp-group-item-flag is-3d))
*sp-particle-system-3d*
*sp-particle-system-2d*
)
a1-4
(-> a3-0 origin)
a3-0
obj
f0-4
)
)
)
)
(label cfg-77)
(b! #t cfg-79 :delay (nop!))
(label cfg-78)
(format 0 "spawn called for non-sparticle-launcher~%")
)
)
)
)
)
)
0
)
;; definition for function sparticle-track-root
;; INFO: Return type mismatch int vs none.
(defun sparticle-track-root ((arg0 object) (arg1 sparticle-cpuinfo) (arg2 vector))
(let ((v1-3 (-> (the-as process-drawable (-> arg1 key proc)) root trans)))
(set! (-> arg2 x) (-> v1-3 x))
(set! (-> arg2 y) (-> v1-3 y))
(set! (-> arg2 z) (-> v1-3 z))
)
0
(none)
)
;; definition for function sparticle-track-root-prim
;; INFO: Return type mismatch int vs none.
(defun sparticle-track-root-prim ((arg0 object) (arg1 sparticle-cpuinfo) (arg2 vector))
(let ((v1-4 (-> (the-as collide-shape (-> (the-as process-drawable (-> arg1 key proc)) root)) root-prim prim-core))
)
(set! (-> arg2 x) (-> v1-4 world-sphere x))
(set! (-> arg2 y) (-> v1-4 world-sphere y))
(set! (-> arg2 z) (-> v1-4 world-sphere z))
)
0
(none)
)
;; definition for function birth-func-copy-rot-color
;; INFO: Return type mismatch int vs none.
(defun birth-func-copy-rot-color ((arg0 sparticle-system)
(arg1 sparticle-cpuinfo)
(arg2 sprite-vec-data-3d)
(arg3 sparticle-launcher)
(arg4 sparticle-launch-state)
)
(local-vars (v1-4 float) (v1-5 float))
(rlet ((vf0 :class vf)
(vf1 :class vf)
(vf2 :class vf)
)
(init-vf0-vector)
(let ((s5-0 (-> arg4 sprite)))
(let ((s4-0 (new 'stack-no-clear 'vector)))
(let* ((v1-0 arg2)
(f0-0 (-> v1-0 qx-qy-qz-sy x))
(f1-0 (-> v1-0 qx-qy-qz-sy y))
(f3-0 (-> v1-0 qx-qy-qz-sy z))
)
(set! (-> s4-0 x) f0-0)
(set! (-> s4-0 y) f1-0)
(set! (-> s4-0 z) f3-0)
(set! (-> s4-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0))))
)
(quaternion-rotate-y! (the-as quaternion s4-0) (the-as quaternion s4-0) (-> s5-0 sprite rot))
(let ((v1-3 arg2))
(cond
((< (-> s4-0 w) 0.0)
(.lvf vf1 (&-> v1-3 qx-qy-qz-sy quad))
(.lvf vf2 (&-> s4-0 quad))
(.sub.vf vf1 vf0 vf2 :mask #b111)
(.svf (&-> v1-3 qx-qy-qz-sy quad) vf1)
(.mov v1-4 vf1)
)
(else
(.lvf vf1 (&-> v1-3 qx-qy-qz-sy quad))
(.lvf vf2 (&-> s4-0 quad))
(.add.vf vf1 vf0 vf2 :mask #b111)
(.svf (&-> v1-3 qx-qy-qz-sy quad) vf1)
(.mov v1-5 vf1)
)
)
)
)
(set! (-> arg2 r-g-b-a x) (-> s5-0 sprite r))
(set! (-> arg2 r-g-b-a y) (-> s5-0 sprite g))
(set! (-> arg2 r-g-b-a z) (-> s5-0 sprite b))
)
0
(none)
)
)
;; definition for symbol *global-toggle*, type int
(define *global-toggle* 0)
;; definition for function birth-func-copy2-rot-color
;; INFO: Return type mismatch int vs none.
;; Used lq/sq
(defun birth-func-copy2-rot-color ((arg0 sparticle-system)
(arg1 sparticle-cpuinfo)
(arg2 sprite-vec-data-3d)
(arg3 sparticle-launcher)
(arg4 sparticle-launch-state)
)
(local-vars (v1-15 float) (v1-16 float))
(rlet ((vf0 :class vf)
(vf1 :class vf)
(vf2 :class vf)
)
(init-vf0-vector)
(let ((s5-0 (-> arg4 sprite)))
(let ((s4-0 (new 'stack-no-clear 'vector)))
(let* ((v1-0 arg2)
(f0-0 (-> v1-0 qx-qy-qz-sy x))
(f1-0 (-> v1-0 qx-qy-qz-sy y))
(f3-0 (-> v1-0 qx-qy-qz-sy z))
)
(set! (-> s4-0 x) f0-0)
(set! (-> s4-0 y) f1-0)
(set! (-> s4-0 z) f3-0)
(set! (-> s4-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0))))
)
(let ((a1-1 (new-stack-vector0)))
(set! (-> a1-1 y) (-> s5-0 sprite rot))
(set! (-> a1-1 z) (if (logtest? *global-toggle* 1)
(the float (sar (shl (the int (- 16384.0 (-> s5-0 sprite sx))) 48) 48))
(the float (sar (shl (the int (+ 16384.0 (-> s5-0 sprite sx))) 48) 48))
)
)
(quaternion-zxy! (the-as quaternion s4-0) a1-1)
)
(let ((v1-14 arg2))
(cond
((< (-> s4-0 w) 0.0)
(.lvf vf1 (&-> v1-14 qx-qy-qz-sy quad))
(.lvf vf2 (&-> s4-0 quad))
(.sub.vf vf1 vf0 vf2 :mask #b111)
(.svf (&-> v1-14 qx-qy-qz-sy quad) vf1)
(.mov v1-15 vf1)
)
(else
(.lvf vf1 (&-> v1-14 qx-qy-qz-sy quad))
(.lvf vf2 (&-> s4-0 quad))
(.add.vf vf1 vf0 vf2 :mask #b111)
(.svf (&-> v1-14 qx-qy-qz-sy quad) vf1)
(.mov v1-16 vf1)
)
)
)
)
(set! (-> arg2 r-g-b-a x) (-> s5-0 sprite r))
(set! (-> arg2 r-g-b-a y) (-> s5-0 sprite g))
(set! (-> arg2 r-g-b-a z) (-> s5-0 sprite b))
)
(set! *global-toggle* (+ *global-toggle* 1))
0
(none)
)
)
;; definition for function birth-func-copy-omega-to-z
;; INFO: Return type mismatch int vs none.
(defun birth-func-copy-omega-to-z ((arg0 sparticle-system)
(arg1 sparticle-cpuinfo)
(arg2 sprite-vec-data-3d)
(arg3 sparticle-launcher)
(arg4 sparticle-launch-state)
)
(set! (-> arg2 qx-qy-qz-sy z) (+ -16384.0 (-> arg1 omega)))
(set! (-> arg1 next-time) (-> arg4 sprite next-time))
(set! (-> arg2 x-y-z-sx w) (* 163.85638 (the float (-> arg4 sprite next-time))))
0
(none)
)
;; definition for function birth-func-random-next-time
;; INFO: Return type mismatch int vs none.
(defun birth-func-random-next-time ((arg0 sparticle-system)
(arg1 sparticle-cpuinfo)
(arg2 sprite-vec-data-3d)
(arg3 sparticle-launcher)
(arg4 sparticle-launch-state)
)
(set! (-> arg1 next-time) (the-as uint (the int (rand-vu-float-range 0.0 (-> arg1 user-float)))))
0
(none)
)
Reference in New Issue View Git Blame Copy Permalink