;;-*-Lisp-*-
(in-package goal)

;; name: sparticle.gc
;; name in dgo: sparticle
;; dgos: GAME

;; DECOMP BEGINS

;; WARN: Return type mismatch object vs sparticle-cpuinfo.
(defmethod print ((this sparticle-cpuinfo))
  (format #t "<sparticle-cpuinfo>~%")
  (dotimes (s5-0 16)
    (format #t "~D:~F~%" s5-0 (the-as float (-> this data s5-0)))
    )
  (format #t "TIMER:~D~%" (-> this timer))
  (the-as sparticle-cpuinfo (format #t "FLAGS:~X~%" (-> this flags)))
  )

;; WARN: Return type mismatch (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d uint none) vs none.
(defun sp-particle-copy! ((arg0 sparticle-cpuinfo) (arg1 sparticle-cpuinfo))
  (let ((v1-1 (-> arg1 sprite x-y-z-sx quad)))
    (set! (-> arg0 sprite x-y-z-sx quad) v1-1)
    )
  (let ((v1-3 (-> arg1 sprite flag-rot-sy quad)))
    (set! (-> arg0 sprite flag-rot-sy quad) v1-3)
    )
  (let ((v1-5 (-> arg1 sprite r-g-b-a quad)))
    (set! (-> arg0 sprite r-g-b-a quad) v1-5)
    )
  (dotimes (v1-6 10)
    (set! (-> arg0 adgif prims v1-6) (-> arg1 adgif prims v1-6))
    )
  (set! (-> arg0 vel-sxvel quad) (-> arg1 vel-sxvel quad))
  (set! (-> arg0 rot-syvel quad) (-> arg1 rot-syvel quad))
  (set! (-> arg0 fade quad) (-> arg1 fade quad))
  (set! (-> arg0 acc quad) (-> arg1 acc quad))
  (set! (-> arg0 friction) (-> arg1 friction))
  (set! (-> arg0 timer) (-> arg1 timer))
  (set! (-> arg0 flags) (-> arg1 flags))
  (set! (-> arg0 user-float) (-> arg1 user-float))
  (set! (-> arg0 sp-func) (-> arg1 sp-func))
  (none)
  )

(defmethod new sparticle-system ((allocation symbol)
                               (type-to-make type)
                               (arg0 int)
                               (arg1 int)
                               (arg2 symbol)
                               (arg3 pointer)
                               (arg4 (inline-array adgif-shader))
                               )
  ;; og:preserve-this
  (#when PC_BIG_MEMORY
    (*! arg0 SPRITE_MAX_AMOUNT_MULT)
    ; (*! arg1 SPRITE_MAX_AMOUNT_MULT)
    )
  (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (let* ((v1-3 (/ (+ arg0 63) 64))
           (a0-2 (/ (+ arg1 63) 64))
           (a1-2 (* v1-3 64))
           (a2-2 (* a0-2 64))
           (s2-1 (+ v1-3 a0-2))
           (s5-1 (+ a1-2 a2-2))
           )
      (set! (-> gp-0 blocks 0) v1-3)
      (set! (-> gp-0 length 0) a1-2)
      (set! (-> gp-0 num-alloc 0) 0)
      (set! (-> gp-0 blocks 1) a0-2)
      (set! (-> gp-0 length 1) a2-2)
      (set! (-> gp-0 num-alloc 1) 0)
      (set! (-> gp-0 is-3d) (the-as basic arg2))
      (set! (-> gp-0 alloc-table) (the-as (pointer uint64) (malloc 'global (* s2-1 8))))
      (set! (-> gp-0 cpuinfo-table) (the-as (inline-array sparticle-cpuinfo) (malloc 'global (* 144 s5-1))))
      (set! (-> gp-0 vecdata-table) arg3)
      (set! (-> gp-0 adgifdata-table) arg4)
      (dotimes (v1-5 s2-1)
        (set! (-> gp-0 alloc-table v1-5) (the-as uint -1))
        )
      (dotimes (s4-1 s5-1)
        (set! (-> gp-0 cpuinfo-table s4-1 valid) (the-as uint 0))
        (set! (-> gp-0 cpuinfo-table s4-1 sprite)
              (the-as sprite-vec-data-2d (&+ (-> gp-0 vecdata-table) (* 48 s4-1)))
              )
        (set! (-> gp-0 cpuinfo-table s4-1 adgif) (-> gp-0 adgifdata-table s4-1))
        (adgif-shader<-texture-simple! (-> gp-0 adgifdata-table s4-1) (the-as texture #f))
        (set! (-> gp-0 adgifdata-table s4-1 alpha) (new 'static 'gs-miptbp :tbp1 #x48))
        )
      )
    gp-0
    )
  )

(kmemopen global "part-systems")

(define *sp-particle-system-2d*
  (new 'global 'sparticle-system 1920 128 #f (-> *sprite-array-2d* vec-data) (-> *sprite-array-2d* adgif-data))
  )

(define *sp-particle-system-3d*
  (new 'global 'sparticle-system 256 0 #t (-> *sprite-array-3d* vec-data) (-> *sprite-array-3d* adgif-data))
  )

(kmemclose)

(defun sp-get-block-size ((arg0 sparticle-system) (arg1 int))
  (let ((v0-0 0))
    (let ((v1-0 0)
          (a2-0 (-> arg0 blocks 0))
          )
      (when (= arg1 1)
        (set! v1-0 a2-0)
        (set! a2-0 (-> arg0 blocks 1))
        )
      (dotimes (a1-3 a2-0)
        (if (!= (-> arg0 alloc-table (+ v1-0 a1-3)) -1)
            (set! v0-0 (+ a1-3 1))
            )
        )
      )
    v0-0
    )
  )

(defun sp-get-approx-alloc-size ((arg0 sparticle-system) (arg1 int))
  (let ((a3-0 arg1)
        (v1-0 0)
        )
    (let ((a1-1 0)
          (a2-0 (-> arg0 blocks 0))
          )
      (when (= a3-0 1)
        (set! a1-1 a2-0)
        (set! a2-0 (-> arg0 blocks 1))
        )
      (dotimes (a3-3 a2-0)
        (if (!= (-> arg0 alloc-table (+ a1-1 a3-3)) -1)
            (set! v1-0 (+ a3-3 1))
            )
        )
      )
    (* v1-0 64)
    )
  )

(defun sp-free-particle ((arg0 sparticle-system) (arg1 int) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-2d))
  (if (and (-> arg2 binding) (nonzero? (-> arg2 binding)))
      (logclear! (-> arg2 binding flags) (sp-launch-state-flags sp0 sp1))
      )
  (let ((v1-6 (/ arg1 64))
        (t0-4 (logand arg1 63))
        )
    (logior! (-> arg0 alloc-table v1-6) (ash 1 t0-4))
    )
  (if (< arg1 (-> arg0 length 0))
      (+! (-> arg0 num-alloc 0) -1)
      (+! (-> arg0 num-alloc 1) -1)
      )
  (set! (-> arg2 valid) (the-as uint 0))
  (set! (-> arg3 r-g-b-a w) 0.0)
  0
  (none)
  )

;; ERROR: Unsupported inline assembly instruction kind - [movz a2, t3, t2]
;; ERROR: Unsupported inline assembly instruction kind - [movz a2, t3, t2]
;; ERROR: Unsupported inline assembly instruction kind - [movz a2, t3, t2]
;; ERROR: Unsupported inline assembly instruction kind - [movz a2, t3, t2]
;; ERROR: Unsupported inline assembly instruction kind - [movz a2, t3, t2]
;; ERROR: Unsupported inline assembly instruction kind - [movz a2, t2, t1]
(defun sp-get-particle ((arg0 sparticle-system) (arg1 int) (arg2 sparticle-launch-state))
  (local-vars
    (a2-3 int)
    (a2-4 int)
    (a2-5 int)
    (a2-6 int)
    (a2-7 int)
    (a2-8 int)
    (t1-16 int)
    (t1-17 int)
    (t1-18 int)
    (t1-19 int)
    (t1-20 int)
    (t3-5 int)
    )
  (let ((v1-0 0)
        (t0-0 (-> arg0 blocks 0))
        (a3-0 0)
        )
    (when (= arg1 1)
      (set! v1-0 t0-0)
      (set! t0-0 (-> arg0 blocks 1))
      )
    (when arg2
      (set! a3-0 (the-as int (-> arg2 randomize)))
      (+! (-> arg2 randomize) 1)
      (when (= (-> arg2 randomize) t0-0)
        (set! (-> arg2 randomize) (the-as uint 0))
        0
        )
      )
    (dotimes (a2-1 t0-0)
      (when (nonzero? (-> arg0 alloc-table (+ v1-0 a3-0)))
        (let ((a2-2 0)
              (t1-15 (-> arg0 alloc-table (+ v1-0 a3-0)))
              (t0-4 (* (+ v1-0 a3-0) 64))
              )
          0
          0
          (let ((t2-4 (shl t1-15 32))
                (t3-0 (+ a2-2 32))
                )
            (move-if-not-zero t1-16 t2-4 t2-4 t1-15)
            (.movz a2-3 t3-0 t2-4 a2-2)
            )
          (let ((t2-5 (shl t1-16 16))
                (t3-1 (+ a2-3 16))
                )
            (move-if-not-zero t1-17 t2-5 t2-5 t1-16)
            (.movz a2-4 t3-1 t2-5 a2-3)
            )
          (let ((t2-6 (* t1-17 256))
                (t3-2 (+ a2-4 8))
                )
            (move-if-not-zero t1-18 t2-6 t2-6 t1-17)
            (.movz a2-5 t3-2 t2-6 a2-4)
            )
          (let ((t2-7 (* t1-18 16))
                (t3-3 (+ a2-5 4))
                )
            (move-if-not-zero t1-19 t2-7 t2-7 t1-18)
            (.movz a2-6 t3-3 t2-7 a2-5)
            )
          (let ((t2-8 (* t1-19 4))
                (t3-4 (+ a2-6 2))
                )
            (move-if-not-zero t1-20 t2-8 t2-8 t1-19)
            (.movz a2-7 t3-4 t2-8 a2-6)
            (let ((t1-21 (* t1-20 2))
                  (t2-9 (+ a2-7 1))
                  )
              (move-if-not-zero t3-5 t1-21 t1-21 t3-4)
              (.movz a2-8 t2-9 t1-21 a2-7)
              )
            )
          (let ((t0-5 (+ t0-4 a2-8)))
            (logxor! (-> arg0 alloc-table (+ v1-0 a3-0)) (the-as uint (ash 1 a2-8)))
            (+! (-> arg0 num-alloc arg1) 1)
            (let ((v1-9 (-> arg0 cpuinfo-table t0-5)))
              (set! (-> v1-9 valid) (the-as uint 1))
              (return v1-9)
              )
            )
          )
        )
      (+! a3-0 1)
      (if (= a3-0 t0-0)
          (set! a3-0 0)
          )
      )
    )
  (the-as sparticle-cpuinfo #f)
  )

(defun sp-kill-particle ((arg0 sparticle-system) (arg1 sparticle-cpuinfo))
  (cond
    ;; og:preserve-this
    ((in-scratchpad? arg1)
     (set! (-> arg1 timer) 0)
     0
     )
    (else
      (let ((a2-1 (/ (the-as int (- (the-as uint arg1) (the-as uint (the-as uint (-> arg0 cpuinfo-table 0))))) 144)))
        (when (or (< a2-1 0) (>= a2-1 (+ (-> arg0 length 0) (-> arg0 length 1))))
          (format 0 "Tried to release particle ~D~%" a2-1)
          (return #f)
          )
        (sp-free-particle arg0 a2-1 arg1 (-> arg1 sprite))
        )
      )
    )
  #t
  )

(defun sp-orbiter ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 vector))
  (let* ((f2-0 (-> arg1 omega))
         (f0-0 (-> arg1 radius))
         (f3-0 (-> arg1 vel-sxvel x))
         (f30-0 (-> arg1 vel-sxvel y))
         (f1-0 (-> arg1 vel-sxvel z))
         (f4-0 (-> *display* clock (-> arg1 clock-index) sparticle-data y))
         (f26-0 (+ f2-0 (* f3-0 f4-0)))
         )
    (set! (-> arg1 omega) f26-0)
    (let ((f28-0 (+ f0-0 (* f1-0 f4-0))))
      (set! (-> arg1 radius) f28-0)
      (let ((f24-0 (sin f26-0))
            (f26-1 (cos f26-0))
            (f22-0 (sin (/ f30-0 2)))
            (f0-5 (cos (/ f30-0 2)))
            (a2-1 (new 'stack-no-clear 'quaternion))
            (s4-0 (new 'stack-no-clear 'vector))
            )
        (let ((s3-0 (new 'stack-no-clear 'matrix)))
          (set-vector! a2-1 (* f22-0 f26-1) 0.0 (* f22-0 f24-0) f0-5)
          (quaternion*! (-> arg1 rotvel3d) (-> arg1 rotvel3d) a2-1)
          (quaternion-normalize! (-> arg1 rotvel3d))
          (set-vector! s4-0 (* f24-0 f28-0) 0.0 (* f26-1 f28-0) 1.0)
          (quaternion->matrix s3-0 (-> arg1 rotvel3d))
          (vector-matrix*! s4-0 s4-0 s3-0)
          )
        (let ((v1-8 (the-as sprite-vec-data-2d (-> arg1 user-float))))
          (set! (-> arg2 x) (+ (-> s4-0 x) (-> v1-8 x-y-z-sx x)))
          (set! (-> arg2 y) (+ (-> s4-0 y) (-> v1-8 x-y-z-sx y)))
          (set! (-> arg2 z) (+ (-> s4-0 z) (-> v1-8 x-y-z-sx z)))
          )
        )
      )
    )
  0
  (none)
  )

(def-mips2c sp-process-block-2d (function sparticle-system int int int int symbol none))

(def-mips2c sp-process-block-3d (function sparticle-system int int int int symbol none))

(defun sp-copy-to-spr ((arg0 int) (arg1 pointer) (arg2 int))
  (let ((a2-1 (/ (+ arg2 15) 16)))
    ;; og:preserve-this
    ; (dma-send-to-spr-no-flush (the-as uint arg0) (the-as uint arg1) (the-as uint a2-1) #t)
    (__mem-move (&+ (scratchpad-start) arg0) arg1 (the uint (* a2-1 16)))
    )
  0
  (none)
  )

(defun sp-copy-from-spr ((arg0 int) (arg1 pointer) (arg2 int))
  (let ((a2-1 (/ (+ arg2 15) 16)))
    ;; og:preserve-this
    ; (dma-send-from-spr-no-flush (the-as uint arg1) (the-as uint arg0) (the-as uint a2-1) #t)
    (__mem-move arg1 (&+ (scratchpad-start) arg0) (the uint (* a2-1 16)))
    )
  0
  (none)
  )

;; ERROR: function was not converted to expressions. Cannot decompile.

(defun sp-process-block ((arg0 sparticle-system) (arg1 int) (arg2 sprite-array-2d) (arg3 int))
  (local-vars (sv-16 int) (sv-32 int) (sv-48 int) (sv-64 int))
  (let ((s3-0 352)
        (s2-0 (* 144 arg3))
        (s5-0 (* 48 arg3))
        )
    (set! sv-32 (* 80 arg3))
    (let ((s1-0 (+ s3-0 s2-0)))
      (set! sv-16 (+ s1-0 s5-0))
      (sp-copy-to-spr s3-0 (the-as pointer (-> arg0 cpuinfo-table arg1)) s2-0)
      (sp-copy-to-spr s1-0 (&+ (-> arg0 vecdata-table) (* 48 arg1)) s5-0)
      (let ((t9-2 sp-copy-to-spr)
            (a1-7 (-> arg0 adgifdata-table arg1))
            )
        (t9-2 sv-16 (the-as pointer a1-7) sv-32)
        )
      ;; og:preserve-this
      (set! sv-48 (+ (the int (scratchpad-start)) s3-0))
      (set! sv-64 (+ (the int (scratchpad-start)) s1-0))
      (let ((t1-0 (paused?)))
        (cond
          ((-> arg0 is-3d)
           (let ((t9-4 sp-process-block-3d)
                 (a0-6 arg0)
                 (a3-1 arg1)
                 )
             (t9-4 a0-6 sv-48 sv-64 a3-1 arg3 t1-0)
             )
           )
          (else
            (sp-process-block-2d arg0 sv-48 sv-64 arg1 arg3 t1-0)
            )
          )
        )
      (sp-copy-from-spr s3-0 (the-as pointer (-> arg0 cpuinfo-table arg1)) s2-0)
      (sp-copy-from-spr s1-0 (&+ (-> arg0 vecdata-table) (* 48 arg1)) s5-0)
      )
    )
  0
  (none)
  )

(defun sp-process-particle-system ((arg0 sparticle-system) (arg1 int) (arg2 sprite-array-2d))
  (countdown (v1-0 22)
    (let ((a0-4 (-> *display* clock v1-0 sparticle-data quad)))
      ;; og:preserve-this
      (set! (-> (the-as vector (+ (the int (scratchpad-start)) (* v1-0 16))) quad) a0-4)
      )
    )
  (let* ((v1-3 352)
         (s1-0 (/ (- #x4000 v1-3) 272))
         (s2-0 0)
         (s3-0 (sp-get-approx-alloc-size arg0 arg1))
         )
    (if (= arg1 1)
        (set! s2-0 (* (-> arg0 blocks 0) 64))
        )
    (set! (-> arg2 num-valid arg1) s3-0)
    (flush-cache 0)
    (while (>= s3-0 s1-0)
      (sp-process-block arg0 s2-0 arg2 s1-0)
      (set! s3-0 (- s3-0 s1-0))
      (+! s2-0 s1-0)
      )
    (if (> s3-0 0)
        (sp-process-block arg0 s2-0 arg2 s3-0)
        )
    )
  0
  (none)
  )

(define-perm *particles-flag* symbol #t)

(defun forall-particles-with-key-runner ((arg0 sparticle-launch-control)
                                (arg1 (function sparticle-system sparticle-cpuinfo none))
                                (arg2 sparticle-system)
                                )
  (local-vars (sv-16 int))
  (let ((s3-0 (the-as object (-> arg2 cpuinfo-table 0)))
        (s2-0 (&+ (-> arg2 vecdata-table) 0))
        (s1-0 (+ (-> arg2 blocks 0) (-> arg2 blocks 1)))
        )
    (dotimes (s0-0 s1-0)
      (cond
        ((!= (-> arg2 alloc-table s0-0) -1)
         (set! sv-16 0)
         (while (< sv-16 64)
           (if (and (nonzero? (-> (the-as sparticle-cpuinfo s3-0) valid)) (= (-> (the-as sparticle-cpuinfo s3-0) key) arg0))
               (arg1 arg2 (the-as sparticle-cpuinfo s3-0))
               )
           (set! s3-0 (-> (the-as (inline-array sparticle-cpuinfo) s3-0) 1))
           (&+! s2-0 48)
           (set! sv-16 (+ sv-16 1))
           )
         )
        (else
          (set! s3-0 (-> (the-as (inline-array sparticle-cpuinfo) s3-0) 64))
          (&+! s2-0 3072)
          )
        )
      )
    )
  0
  (none)
  )

(defun forall-particles-with-key ((arg0 sparticle-launch-control)
                         (arg1 (function sparticle-system sparticle-cpuinfo none))
                         (arg2 symbol)
                         (arg3 symbol)
                         )
  (if arg2
      (forall-particles-with-key-runner arg0 arg1 *sp-particle-system-2d*)
      )
  (if arg3
      (forall-particles-with-key-runner arg0 arg1 *sp-particle-system-3d*)
      )
  0
  (none)
  )

(defun sparticle-kill-it ((arg0 sparticle-system) (arg1 sparticle-cpuinfo))
  (set! (-> arg1 timer) 0)
  (set! (-> arg1 sp-func) (the-as (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d uint none) 0))
  (when (and (-> arg1 binding) (nonzero? (-> arg1 binding)))
    (logclear! (-> arg1 binding flags) (sp-launch-state-flags sp0 sp1))
    (set! (-> arg1 binding) #f)
    )
  0
  (none)
  )

(define *sparticle-kill-it-level* 0)

(defun sparticle-kill-it-level ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 pointer))
  (if (= (logand (shr (the-as int (-> arg1 flags)) 9) 15) *sparticle-kill-it-level*)
      (sparticle-kill-it arg0 arg1)
      )
  0
  (none)
  )

(defun sparticle-60-to-50 ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 pointer))
  (let ((gp-0 (-> arg1 rotvel3d))
        (s5-0 (new 'stack-no-clear 'vector))
        )
    (vector-angle<-quaternion! s5-0 gp-0)
    (set! (-> s5-0 w) (* 12516.455 (-> s5-0 w)))
    (quaternion-vector-angle! gp-0 s5-0 (-> s5-0 w))
    )
  0
  (none)
  )

(defun sparticle-50-to-60 ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 pointer))
  (let ((gp-0 (-> arg1 rotvel3d))
        (s5-0 (new 'stack-no-clear 'vector))
        )
    (vector-angle<-quaternion! s5-0 gp-0)
    (set! (-> s5-0 w) (* 8691.982 (-> s5-0 w)))
    (quaternion-vector-angle! gp-0 s5-0 (-> s5-0 w))
    )
  0
  (none)
  )

(defun kill-all-particles-with-key ((arg0 sparticle-launch-control))
  (forall-particles-with-key arg0 sparticle-kill-it #t #t)
  0
  (none)
  )

(defun forall-particles-runner ((arg0 (function sparticle-system sparticle-cpuinfo pointer none)) (arg1 sparticle-system))
  (let ((s4-0 (the-as object (-> arg1 cpuinfo-table 0)))
        (s3-0 (&+ (-> arg1 vecdata-table) 0))
        (s2-0 (+ (-> arg1 blocks 0) (-> arg1 blocks 1)))
        )
    (dotimes (s1-0 s2-0)
      (cond
        ((!= (-> arg1 alloc-table s1-0) -1)
         (dotimes (s0-0 64)
           (if (nonzero? (-> (the-as sparticle-cpuinfo s4-0) valid))
               (arg0 arg1 (the-as sparticle-cpuinfo s4-0) s3-0)
               )
           (set! s4-0 (+ (the-as uint s4-0) 144))
           (&+! s3-0 48)
           )
         )
        (else
          (set! s4-0 (&+ (the-as pointer s4-0) 9216))
          (&+! s3-0 3072)
          )
        )
      )
    )
  0
  (none)
  )

(defun forall-particles ((arg0 function) (arg1 symbol) (arg2 symbol))
  (if arg1
      (forall-particles-runner
        (the-as (function sparticle-system sparticle-cpuinfo pointer none) arg0)
        *sp-particle-system-2d*
        )
      )
  (if arg2
      (forall-particles-runner
        (the-as (function sparticle-system sparticle-cpuinfo pointer none) arg0)
        *sp-particle-system-3d*
        )
      )
  0
  (none)
  )

(defun kill-all-particles-in-level ((arg0 level))
  (set! *sparticle-kill-it-level* (-> arg0 index))
  (forall-particles sparticle-kill-it-level #t #t)
  0
  )

(defun all-particles-50-to-60 ()
  (forall-particles-runner sparticle-50-to-60 *sp-particle-system-3d*)
  (none)
  )

(defun all-particles-60-to-50 ()
  (forall-particles-runner sparticle-60-to-50 *sp-particle-system-3d*)
  (none)
  )

;; WARN: Return type mismatch gs-miptbp vs none.
(defun remap-particle ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 pointer))
  (let* ((gp-0 (-> arg1 adgif))
         (a0-1 (-> gp-0 texture-id))
         (v1-0 (lookup-texture-by-id-fast a0-1))
         )
    (when v1-0
      (set! (-> gp-0 tex0 tbp0) (-> v1-0 dest 0))
      (set! (-> gp-0 tex0 cbp) (-> v1-0 clutdest))
      (set! (-> gp-0 miptbp1 tbp1) (-> v1-0 dest 1))
      (set! (-> gp-0 miptbp1 tbp2) (-> v1-0 dest 2))
      (set! (-> gp-0 miptbp1 tbp3) (-> v1-0 dest 3))
      )
    )
  (none)
  )

(defun remap-all-particles ()
  (forall-particles remap-particle #t #t)
  (none)
  )

;; ERROR: Unsupported inline assembly instruction kind - [mfc0 gp, Count]
;; ERROR: Unsupported inline assembly instruction kind - [mfc0 v1, Count]
(defun process-particles ()
  (local-vars (v1-53 int) (gp-0 int))
  (with-pp
    (when *particles-flag*
      0
      0
      (.mfc0 gp-0 Count)
      (set! *sp-launcher-lock* #t)
      (when *debug-segment*
        (let ((s5-0 (-> *display* frames (-> *display* on-screen) profile-array data 0))
              (v1-12 'particle)
              (s4-0 *profile-particle-color*)
              )
          (when (and *dproc* *debug-segment*)
            (let ((s3-0 (-> s5-0 data (-> s5-0 count))))
              (let ((s2-0 (-> s5-0 base-time)))
                (set! (-> s3-0 name) v1-12)
                (set! (-> s3-0 start-time) (the-as int (- (timer-count (the-as timer-bank #x10000800)) (the-as uint s2-0))))
                )
              (set! (-> s3-0 depth) (the-as uint (-> s5-0 depth)))
              (set! (-> s3-0 color) s4-0)
              (set! (-> s5-0 segment (-> s5-0 depth)) s3-0)
              )
            (set! (-> s5-0 count) (min 1023 (+ (-> s5-0 count) 1)))
            (+! (-> s5-0 depth) 1)
            (set! (-> s5-0 max-depth) (max (-> s5-0 max-depth) (-> s5-0 depth)))
            )
          )
        0
        )
      (logand (the-as int (-> pp clock sparticle-data x)) 255)
      (cond
        (*sp-60-hz*
          (when (= (-> *setting-control* user-current video-mode) 'pal)
            (set! *sp-60-hz* #f)
            (all-particles-60-to-50)
            )
          )
        (else
          (when (= (-> *setting-control* user-current video-mode) 'ntsc)
            (set! *sp-60-hz* #t)
            (all-particles-50-to-60)
            )
          )
        )
      (clear-sprite-aux-list)
      (sp-process-particle-system *sp-particle-system-2d* 0 *sprite-array-2d*)
      (sp-process-particle-system *sp-particle-system-2d* 1 *sprite-array-2d*)
      (sp-process-particle-system *sp-particle-system-3d* 0 (the-as sprite-array-2d *sprite-array-3d*))
      (when *debug-segment*
        (let ((s5-1 (-> *display* frames (-> *display* on-screen) profile-array data 0)))
          (when (and *dproc* *debug-segment*)
            (let* ((v1-47 (+ (-> s5-1 depth) -1))
                   (s4-1 (-> s5-1 segment v1-47))
                   (s3-1 (-> s5-1 base-time))
                   )
              (when (>= v1-47 0)
                (set! (-> s4-1 end-time) (the-as int (- (timer-count (the-as timer-bank #x10000800)) (the-as uint s3-1))))
                (+! (-> s5-1 depth) -1)
                )
              )
            )
          )
        0
        )
      (set! *sp-launcher-lock* #f)
      (sp-clear-queue)
      (.mfc0 v1-53 Count)
      (- v1-53 gp-0)
      (when *display-sprite-info*
        (if (movie?)
            (format *stdcon* "~%~%~%")
            )
        (format
          *stdcon*
          "2d: ~4d~100h3d: ~4d~200hwarp/glow: ~3D~350hhud:~3D~%"
          (-> *sp-particle-system-2d* num-alloc 0)
          (-> *sp-particle-system-3d* num-alloc 0)
          (-> *sprite-aux-list* entry)
          (-> *sp-particle-system-2d* num-alloc 1)
          )
        )
      )
    0
    (none)
    )
  )
