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

;; definition for symbol *collide-list-boxes*, type object
(define *collide-list-boxes* (the-as object #f))

;; definition for symbol *collide-hash-fragments*, type object
(define *collide-hash-fragments* (the-as object 0))

;; definition for symbol *collide-hash-fragments-tfrag*, type object
(define *collide-hash-fragments-tfrag* (the-as object 0))

;; definition for symbol *collide-hash-fragments-instance*, type object
(define *collide-hash-fragments-instance* (the-as object 0))

;; definition for symbol *already-printed-exeeded-max-cache-tris*, type symbol
(define *already-printed-exeeded-max-cache-tris* #f)

;; definition of type collide-hash-scratch
(deftype collide-hash-scratch (structure)
  "Scratchpad memory layout for collide-hash. Bitmask of things that have already been checked"
  ((collidable-bits  uint128  128)
   (poly-bits        uint64   2   :overlay-at (-> collidable-bits 0))
   (id-bits          uint32   512 :overlay-at (-> collidable-bits 0))
   (tris             uint32)
   )
  )

;; definition for method 3 of type collide-hash-scratch
(defmethod inspect ((this collide-hash-scratch))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'collide-hash-scratch)
  (format #t "~1Tcollidable-bits[128] @ #x~X~%" (-> this collidable-bits))
  (format #t "~1Tpoly-bits[2] @ #x~X~%" (-> this collidable-bits))
  (format #t "~1Tid-bits[512] @ #x~X~%" (-> this collidable-bits))
  (format #t "~1Ttris: ~D~%" (-> this tris))
  (label cfg-4)
  this
  )

;; definition of type collide-hash-bucket
(deftype collide-hash-bucket (structure)
  "A bucket is a reference to a list of items that intersect a grid cell.
For the broadphase, the items are collide-hash-item (wrapper of collide-hash-fragment).
For the narrowphase, the items are entries in the index list, which contains poly indices."
  ((index  int16)
   (count  int16)
   )
  )

;; definition for method 3 of type collide-hash-bucket
(defmethod inspect ((this collide-hash-bucket))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'collide-hash-bucket)
  (format #t "~1Tindex: ~D~%" (-> this index))
  (format #t "~1Tcount: ~D~%" (-> this count))
  (label cfg-4)
  this
  )

;; definition of type collide-hash-item
(deftype collide-hash-item (structure)
  "Items that are 'hashed' in the broadphase. Contains unique ID for checking against already-visited-bitmask
and a pointer to the actual collide-hash-fragment, or possibly a TIE."
  ((id          uint32)
   (collidable  basic)
   )
  :pack-me
  )

;; definition for method 3 of type collide-hash-item
(defmethod inspect ((this collide-hash-item))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'collide-hash-item)
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tcollidable: ~A~%" (-> this collidable))
  (label cfg-4)
  this
  )

;; definition of type collide-hash-poly
(deftype collide-hash-poly (structure)
  "A polygon in the narrow-phase data. This is just indices into the vertex and PAT tables."
  ((data         uint8   4)
   (vert-index0  uint8   :overlay-at (-> data 0))
   (vert-index1  uint8   :overlay-at (-> data 1))
   (vert-index2  uint8   :overlay-at (-> data 2))
   (pat-index    uint8   :overlay-at (-> data 3))
   (word         uint32  :overlay-at (-> data 0))
   )
  )

;; definition for method 3 of type collide-hash-poly
(defmethod inspect ((this collide-hash-poly))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'collide-hash-poly)
  (format #t "~1Tdata[4] @ #x~X~%" (&-> this vert-index0))
  (format #t "~1Tvert-index0: ~D~%" (-> this vert-index0))
  (format #t "~1Tvert-index1: ~D~%" (-> this vert-index1))
  (format #t "~1Tvert-index2: ~D~%" (-> this vert-index2))
  (format #t "~1Tpat-index: ~D~%" (-> this pat-index))
  (format #t "~1Tword: ~D~%" (-> this word))
  (label cfg-4)
  this
  )

;; definition of type collide-hash-fragment-stats
(deftype collide-hash-fragment-stats (structure)
  ((num-verts   uint16)
   (num-polys   uint8)
   (poly-count  uint8)
   )
  :pack-me
  )

;; definition for method 3 of type collide-hash-fragment-stats
(defmethod inspect ((this collide-hash-fragment-stats))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'collide-hash-fragment-stats)
  (format #t "~1Tnum-verts: ~D~%" (-> this num-verts))
  (format #t "~1Tnum-polys: ~D~%" (-> this num-polys))
  (format #t "~1Tpoly-count: ~D~%" (-> this poly-count))
  (label cfg-4)
  this
  )

;; definition of type collide-hash-fragment
(deftype collide-hash-fragment (drawable)
  "A mesh fragment for the Jak2/Jak3 collision system. This is a 'hash' of triangles into a grid
where the 'hash' function is just identity."
  ((num-buckets      uint16                               :overlay-at id)
   (num-indices      uint16                               :offset   6)
   (pat-array        uint32                               :offset   8)
   (bucket-array     uint32                               :offset  12)
   (grid-step        vector                       :inline)
   (bbox             bounding-box                 :inline)
   (bbox4w           bounding-box4w               :inline)
   (axis-scale       vector                       :inline :overlay-at (-> bbox max))
   (avg-extents      vector                       :inline :overlay-at (-> bbox4w min data 0))
   (dimension-array  uint32                       4       :overlay-at (-> grid-step data 3))
   (stats            collide-hash-fragment-stats  :inline :overlay-at (-> bbox min data 3))
   (num-verts        uint16                               :overlay-at (-> bbox min data 3))
   (num-polys        uint8                                :offset  62)
   (poly-count       uint8                                :offset  63)
   (poly-array       uint32                               :overlay-at (-> bbox max data 3))
   (vert-array       uint32                               :overlay-at (-> bbox4w min data 3))
   (index-array      uint32                               :overlay-at (-> bbox4w max data 3))
   )
  )

;; definition for method 3 of type collide-hash-fragment
(defmethod inspect ((this collide-hash-fragment))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tbsphere: ~`vector`P~%" (-> this bsphere))
  (format #t "~1Tnum-buckets: ~D~%" (-> this num-buckets))
  (format #t "~1Tnum-indices: ~D~%" (-> this num-indices))
  (format #t "~1Tpat-array: #x~X~%" (-> this pat-array))
  (format #t "~1Tbucket-array: #x~X~%" (-> this bucket-array))
  (format #t "~1Tgrid-step: #<vector @ #x~X>~%" (-> this grid-step))
  (format #t "~1Tbbox: #<bounding-box @ #x~X>~%" (-> this bbox))
  (format #t "~1Tbbox4w: #<bounding-box4w @ #x~X>~%" (-> this bbox4w))
  (format #t "~1Taxis-scale: #<vector @ #x~X>~%" (-> this bbox max))
  (format #t "~1Tavg-extents: #<vector @ #x~X>~%" (-> this bbox4w))
  (format #t "~1Tdimension-array[4] @ #x~X~%" (&-> this grid-step w))
  (format #t "~1Tstats: #<collide-hash-fragment-stats @ #x~X>~%" (&-> this bbox min w))
  (format #t "~1Tnum-verts: ~D~%" (-> this stats num-verts))
  (format #t "~1Tnum-polys: ~D~%" (-> this stats num-polys))
  (format #t "~1Tpoly-count: ~D~%" (-> this stats poly-count))
  (format #t "~1Tpoly-array: #x~X~%" (-> this bbox max w))
  (format #t "~1Tvert-array: #x~X~%" (-> this avg-extents w))
  (format #t "~1Tindex-array: #x~X~%" (-> this index-array))
  (label cfg-4)
  this
  )

;; definition of type collide-hash-fragment-array
(deftype collide-hash-fragment-array (array)
  "A collection of collide-hash-fragments. These are used by the instanced collision if a single instance
needs more than 1 collide-hash-fragment worth of triangles."
  ((fragments  collide-hash-fragment  :dynamic :offset  16)
   )
  )

;; definition for method 3 of type collide-hash-fragment-array
(defmethod inspect ((this collide-hash-fragment-array))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Ttype: ~A~%" (-> this type))
  (format #t "~1Tlength: ~D~%" (-> this length))
  (format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
  (format #t "~1Tcontent-type: ~A~%" (-> this content-type))
  (label cfg-4)
  this
  )

;; definition of type collide-hash
(deftype collide-hash (drawable)
  ((num-ids          uint16                                    :overlay-at id)
   (id-count         uint16                                    :offset   6)
   (num-buckets      uint32                                    :offset   8)
   (qwc-id-bits      uint32                                    :offset  12)
   (grid-step        vector                            :inline :overlay-at bsphere)
   (bbox             bounding-box                      :inline)
   (bbox4w           bounding-box4w                    :inline)
   (axis-scale       vector                            :inline :overlay-at (-> bbox max))
   (avg-extents      vector                            :inline :overlay-at (-> bbox4w min data 0))
   (bucket-array     uint32                                    :overlay-at (-> bbox min data 3))
   (item-array       (inline-array collide-hash-item)          :overlay-at (-> bbox max data 3))
   (dimension-array  uint32                            3       :overlay-at (-> bbox4w min data 3))
   (num-items        uint32                                    :overlay-at (-> bbox4w max data 3))
   )
  )

;; definition for method 3 of type collide-hash
(defmethod inspect ((this collide-hash))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tid: ~D~%" (-> this id))
  (format #t "~1Tbsphere: ~`vector`P~%" (-> this bsphere))
  (format #t "~1Tnum-ids: ~D~%" (-> this num-ids))
  (format #t "~1Tid-count: ~D~%" (-> this id-count))
  (format #t "~1Tnum-buckets: ~D~%" (-> this num-buckets))
  (format #t "~1Tqwc-id-bits: ~D~%" (-> this qwc-id-bits))
  (format #t "~1Tgrid-step: #<vector @ #x~X>~%" (-> this bsphere))
  (format #t "~1Tbbox: #<bounding-box @ #x~X>~%" (-> this bbox))
  (format #t "~1Tbbox4w: #<bounding-box4w @ #x~X>~%" (-> this bbox4w))
  (format #t "~1Taxis-scale: #<vector @ #x~X>~%" (-> this bbox max))
  (format #t "~1Tavg-extents: #<vector @ #x~X>~%" (-> this bbox4w))
  (format #t "~1Tbucket-array: #x~X~%" (-> this bbox min w))
  (format #t "~1Titem-array: #x~X~%" (-> this item-array))
  (format #t "~1Tdimension-array[3] @ #x~X~%" (&-> this bbox4w min w))
  (format #t "~1Tnum-items: ~D~%" (-> this num-items))
  (label cfg-4)
  this
  )

;; failed to figure out what this is:
0