mirror of
https://github.com/open-goal/jak-project
synced 2026-07-09 23:01:56 -04:00
Hat Kid
93afb02cf4
This includes all the collision stuff needed to spawn `target`, decompiles the sparticle code and adds some of the PC hacks needed for merc to run (it doesn't work quite right and looks bad, likely due to a combination of code copied from Jak 2 and the time of day hacks). There are a bunch of temporary hacks (see commits) in place to prevent the game from crashing quite as much, but it is still extremely prone to doing so due to lots of missing functions/potentially bad decomp. --------- Co-authored-by: water <awaterford111445@gmail.com>
265 lines
10 KiB
Common Lisp
Vendored
Generated
265 lines
10 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition for symbol *collide-list-boxes*, type symbol
|
|
(define *collide-list-boxes* #f)
|
|
|
|
;; definition for symbol *collide-hash-fragments*, type int
|
|
(define *collide-hash-fragments* 0)
|
|
|
|
;; definition for symbol *collide-hash-fragments-tfrag*, type int
|
|
(define *collide-hash-fragments-tfrag* 0)
|
|
|
|
;; definition for symbol *collide-hash-fragments-instance*, type int
|
|
(define *collide-hash-fragments-instance* 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 data))
|
|
(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 :offset 32)
|
|
(bbox4w bounding-box4w :inline :offset 64)
|
|
(axis-scale vector :inline :offset 48)
|
|
(avg-extents vector :inline :offset 64)
|
|
(bucket-array uint32 :offset 44)
|
|
(item-array (inline-array collide-hash-item) :overlay-at (-> axis-scale w))
|
|
(dimension-array uint32 3 :overlay-at (-> avg-extents w))
|
|
(num-items uint32 :offset 92)
|
|
)
|
|
)
|
|
|
|
;; 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
|