mirror of
https://github.com/open-goal/jak-project
synced 2026-08-08 18:44:15 -04:00
Tyler Wilding
6181c6c997
When working with mips2c recently, I noticed adding the `defmethod-mips2c` or `def-mips2c` code was a manual step. This is a bit tedious to have to go and do yourself, but more importantly you have to manually go and find the right spot in the source file else you might be declaring it too early or too late. This will automatically output the declaration for methods, and a half-finished comment for the functions. I wasn't able to fully output the function one because it seems the signature info from `all-types` doesn't make it all the way through -- but maybe I'm wrong or this is an easy fix?
1351 lines
47 KiB
Common Lisp
Vendored
Generated
1351 lines
47 KiB
Common Lisp
Vendored
Generated
;;-*-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* (new 'global 'boxed-array sparticle-launcher 3584))
|
|
|
|
;; definition for symbol *part-group-id-table*, type (array sparticle-launch-group)
|
|
(define *part-group-id-table* (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!
|
|
;; INFO: function output is handled by mips2c
|
|
(def-mips2c sp-init-fields! (function object (inline-array sp-field-init-spec) sp-field-id sp-field-id symbol object))
|
|
|
|
;; 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
|
|
;; INFO: function output is handled by mips2c
|
|
(def-mips2c particle-adgif (function adgif-shader texture-id none))
|
|
|
|
;; definition for function sp-queue-launch
|
|
;; INFO: 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 (not (logtest? (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 (not (logtest? (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
|
|
;; INFO: function output is handled by mips2c
|
|
(def-mips2c sp-launch-particles-var (function sparticle-system sparticle-launcher vector sparticle-launch-state sparticle-launch-control float none))
|
|
|
|
;; definition for symbol *death-adgif*, type adgif-shader
|
|
(define *death-adgif* (the-as adgif-shader #f))
|
|
|
|
;; definition for function sp-launch-particles-death
|
|
;; INFO: Used lq/sq
|
|
;; INFO: Return type mismatch int vs none.
|
|
;; WARN: Function sp-launch-particles-death has a return type of none, but the expression builder found a return statement.
|
|
(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.007))))
|
|
(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) 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: Used lq/sq
|
|
;; INFO: Return type mismatch int vs object.
|
|
(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! (not (logtest? (-> v1-29 flags) (sp-group-item-flag launch-asap))) cfg-36 :delay (nop!))
|
|
(when (not (logtest? (-> 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 (not (logtest? (-> 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: Used lq/sq
|
|
;; INFO: Return type mismatch int vs none.
|
|
(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)
|
|
)
|