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

;; definition for symbol *sp-frame-time*, type vector
(define *sp-frame-time* (new 'global 'vector))

;; failed to figure out what this is:
(set-vector! *sp-frame-time* 0.00000000000000000000000000000000000001175495 5.0 1.0 1.0)

;; definition for symbol *sp-60-hz*, type symbol
(define *sp-60-hz* #t)

;; definition of type sparticle-cpuinfo
(deftype sparticle-cpuinfo (structure)
  ((sprite        sprite-vec-data-2d               :offset-assert   0)
   (adgif         adgif-shader                     :offset-assert   4)
   (radius        float                            :offset-assert   8)
   (omega         float                            :offset-assert  12)
   (vel-sxvel     vector                   :inline :offset-assert  16)
   (rot-syvel     vector                   :inline :offset-assert  32)
   (fade          rgbaf                    :inline :offset-assert  48)
   (acc           vector                   :inline :offset-assert  64)
   (rotvel3d      quaternion               :inline :offset-assert  80)
   (vel           vector3s                 :inline :offset         16)
   (accel         vector3s                 :inline :offset         64)
   (scalevelx     float                            :offset         28)
   (scalevely     float                            :offset         44)
   (friction      float                            :offset-assert  96)
   (timer         int32                            :offset-assert 100)
   (flags         sp-cpuinfo-flag                  :offset-assert 104)
   (user-int32    int32                            :offset-assert 108)
   (user-uint32   uint32                           :offset        108)
   (user-float    float                            :offset        108)
   (user-pntr     uint32                           :offset        108)
   (user-sprite   sprite-vec-data-2d               :offset        108)
   (func          basic                            :offset-assert 112)
   (next-time     uint32                           :offset-assert 116)
   (next-launcher basic                            :offset-assert 120)
   (cache-alpha   float                            :offset-assert 124)
   (valid         symbol                           :offset-assert 128)
   (key           sparticle-launch-control         :offset-assert 132)
   (binding       sparticle-launch-state           :offset-assert 136)
   (data          uint32                   1       :offset         12)
   (dataf         float                    1       :offset         12)
   (datac         uint8                    1       :offset         12)
   )
  :method-count-assert 9
  :size-assert         #x8c
  :flag-assert         #x90000008c
  )

;; definition for method 3 of type sparticle-cpuinfo
(defmethod inspect sparticle-cpuinfo ((obj sparticle-cpuinfo))
  (format #t "[~8x] ~A~%" obj 'sparticle-cpuinfo)
  (format #t "~Tsprite: #<sprite-vec-data-2d @ #x~X>~%" (-> obj sprite))
  (format #t "~Tadgif: #<adgif-shader @ #x~X>~%" (-> obj adgif))
  (format #t "~Tradius: ~f~%" (-> obj radius))
  (format #t "~Tomega: ~f~%" (-> obj omega))
  (format #t "~Tvel-sxvel: #<vector @ #x~X>~%" (-> obj vel-sxvel))
  (format #t "~Trot-syvel: #<vector @ #x~X>~%" (-> obj rot-syvel))
  (format #t "~Tfade: #<rgbaf @ #x~X>~%" (-> obj fade))
  (format #t "~Tacc: #<vector @ #x~X>~%" (-> obj acc))
  (format #t "~Trotvel3d: #<quaternion @ #x~X>~%" (-> obj rotvel3d))
  (format #t "~Tvel: #<vector3s @ #x~X>~%" (-> obj vel-sxvel))
  (format #t "~Taccel: #<vector3s @ #x~X>~%" (-> obj acc))
  (format #t "~Tscalevelx: ~f~%" (-> obj vel-sxvel w))
  (format #t "~Tscalevely: ~f~%" (-> obj rot-syvel w))
  (format #t "~Tfriction: ~f~%" (-> obj friction))
  (format #t "~Ttimer: ~D~%" (-> obj timer))
  (format #t "~Tflags: ~D~%" (-> obj flags))
  (format #t "~Tuser-int32: ~D~%" (-> obj user-float))
  (format #t "~Tuser-uint32: ~D~%" (-> obj user-float))
  (format #t "~Tuser-float: ~f~%" (the-as float (-> obj user-float)))
  (format #t "~Tuser-pntr: #x~X~%" (-> obj user-float))
  (format #t "~Tuser-sprite: #<sprite-vec-data-2d @ #x~X>~%" (-> obj user-float))
  (format #t "~Tfunc: ~A~%" (-> obj func))
  (format #t "~Tnext-time: ~D~%" (-> obj next-time))
  (format #t "~Tnext-launcher: ~A~%" (-> obj next-launcher))
  (format #t "~Tcache-alpha: ~f~%" (-> obj cache-alpha))
  (format #t "~Tvalid: ~A~%" (-> obj valid))
  (format #t "~Tkey: ~A~%" (-> obj key))
  (format #t "~Tbinding: #<sparticle-launch-state @ #x~X>~%" (-> obj binding))
  (format #t "~Tdata[1] @ #x~X~%" (&-> obj omega))
  (format #t "~Tdataf[1] @ #x~X~%" (&-> obj omega))
  (format #t "~Tdatac[1] @ #x~X~%" (&-> obj omega))
  obj
  )

;; definition of type sparticle-launchinfo
(deftype sparticle-launchinfo (structure)
  ((launchrot  vector :inline :offset-assert   0)
   (conerot    vector :inline :offset-assert  16)
   (coneradius float          :offset-assert  32)
   (rotate-y   float          :offset-assert  36)
   (data       uint8  1       :offset          0)
   )
  :method-count-assert 9
  :size-assert         #x28
  :flag-assert         #x900000028
  )

;; definition for method 3 of type sparticle-launchinfo
(defmethod inspect sparticle-launchinfo ((obj sparticle-launchinfo))
  (format #t "[~8x] ~A~%" obj 'sparticle-launchinfo)
  (format #t "~Tlaunchrot: #<vector @ #x~X>~%" (-> obj launchrot))
  (format #t "~Tconerot: #<vector @ #x~X>~%" (-> obj conerot))
  (format #t "~Tconeradius: ~f~%" (-> obj coneradius))
  (format #t "~Trotate-y: ~f~%" (-> obj rotate-y))
  (format #t "~Tdata[1] @ #x~X~%" (-> obj launchrot))
  obj
  )

;; definition of type sparticle-system
(deftype sparticle-system (basic)
  ((blocks          int32                            2 :offset-assert   4)
   (length          int32                            2 :offset-assert  12)
   (num-alloc       int32                            2 :offset-assert  20)
   (is-3d           basic                              :offset-assert  28)
   (flags           uint32                             :offset-assert  32)
   (alloc-table     (pointer uint64)                   :offset-assert  36)
   (cpuinfo-table   (inline-array sparticle-cpuinfo)   :offset-assert  40)
   (vecdata-table   pointer                            :offset-assert  44)
   (adgifdata-table (inline-array adgif-shader)        :offset-assert  48)
   )
  :method-count-assert 9
  :size-assert         #x34
  :flag-assert         #x900000034
  (:methods
    (new (symbol type int int symbol pointer (inline-array adgif-shader)) _type_ 0)
    )
  )

;; definition for method 3 of type sparticle-system
(defmethod inspect sparticle-system ((obj sparticle-system))
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~Tblocks[2] @ #x~X~%" (-> obj blocks))
  (format #t "~Tlength[2] @ #x~X~%" (-> obj length))
  (format #t "~Tnum-alloc[2] @ #x~X~%" (-> obj num-alloc))
  (format #t "~Tis-3d: ~A~%" (-> obj is-3d))
  (format #t "~Tflags: ~D~%" (-> obj flags))
  (format #t "~Talloc-table: #x~X~%" (-> obj alloc-table))
  (format #t "~Tcpuinfo-table: #x~X~%" (-> obj cpuinfo-table))
  (format #t "~Tvecdata-table: #x~X~%" (-> obj vecdata-table))
  (format #t "~Tadgifdata-table: #x~X~%" (-> obj adgifdata-table))
  obj
  )

;; failed to figure out what this is:
0