mirror of
https://github.com/open-goal/jak-project
synced 2026-07-01 12:19:08 -04:00
ManDude
cd68cb671e
Major change to how `deftype` shows up in our code: - the decompiler will no longer emit the `offset-assert`, `method-count-assert`, `size-assert` and `flag-assert` parameters. There are extremely few cases where having this in the decompiled code is helpful, as the types there come from `all-types` which already has those parameters. This also doesn't break type consistency because: - the asserts aren't compared. - the first step of the test uses `all-types`, which has the asserts, which will throw an error if they're bad. - the decompiler won't emit the `heap-base` parameter unless necessary now. - the decompiler will try its hardest to turn a fixed-offset field into an `overlay-at` field. It falls back to the old offset if all else fails. - `overlay-at` now supports field "dereferencing" to specify the offset that's within a field that's a structure, e.g.: ```lisp (deftype foobar (structure) ((vec vector :inline) (flags int32 :overlay-at (-> vec w)) ) ) ``` in this structure, the offset of `flags` will be 12 because that is the final offset of `vec`'s `w` field within this structure. - **removed ID from all method declarations.** IDs are only ever automatically assigned now. Fixes #3068. - added an `:overlay` parameter to method declarations, in order to declare a new method that goes on top of a previously-defined method. Syntax is `:overlay <method-name>`. Please do not ever use this. - added `state-methods` list parameter. This lets you quickly specify a list of states to be put in the method table. Same syntax as the `states` list parameter. The decompiler will try to put as many states in this as it can without messing with the method ID order. Also changes `defmethod` to make the first type definition (before the arguments) optional. The type can now be inferred from the first argument. Fixes #3093. --------- Co-authored-by: Hat Kid <6624576+Hat-Kid@users.noreply.github.com>
688 lines
29 KiB
Common Lisp
Vendored
Generated
688 lines
29 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type collide-sticky-rider
|
|
(deftype collide-sticky-rider (structure)
|
|
((rider-handle handle)
|
|
(sticky-prim collide-shape-prim)
|
|
(prim-ry float)
|
|
(rider-local-pos vector :inline)
|
|
)
|
|
(:methods
|
|
(set-rider! (_type_ handle) symbol)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-sticky-rider
|
|
(defmethod inspect ((this collide-sticky-rider))
|
|
(format #t "[~8x] ~A~%" this 'collide-sticky-rider)
|
|
(format #t "~Trider-handle: ~D~%" (-> this rider-handle))
|
|
(format #t "~Tsticky-prim: ~A~%" (-> this sticky-prim))
|
|
(format #t "~Tprim-ry: ~f~%" (-> this prim-ry))
|
|
(format #t "~Trider-local-pos: #<vector @ #x~X>~%" (-> this rider-local-pos))
|
|
this
|
|
)
|
|
|
|
;; definition for method 9 of type collide-sticky-rider
|
|
(defmethod set-rider! ((this collide-sticky-rider) (arg0 handle))
|
|
(set! (-> this rider-handle) arg0)
|
|
(set! (-> this sticky-prim) #f)
|
|
#f
|
|
)
|
|
|
|
;; definition of type collide-sticky-rider-group
|
|
(deftype collide-sticky-rider-group (basic)
|
|
((num-riders int32)
|
|
(allocated-riders int32)
|
|
(rider collide-sticky-rider 1 :inline)
|
|
)
|
|
(:methods
|
|
(new (symbol type int) _type_)
|
|
(add-rider! (_type_ process-drawable) collide-sticky-rider)
|
|
(reset! (_type_) int)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-sticky-rider-group
|
|
(defmethod inspect ((this collide-sticky-rider-group))
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~Tnum-riders: ~D~%" (-> this num-riders))
|
|
(format #t "~Tallocated-riders: ~D~%" (-> this allocated-riders))
|
|
(format #t "~Trider[1] @ #x~X~%" (-> this rider))
|
|
this
|
|
)
|
|
|
|
;; definition for method 10 of type collide-sticky-rider-group
|
|
(defmethod reset! ((this collide-sticky-rider-group))
|
|
(set! (-> this num-riders) 0)
|
|
0
|
|
)
|
|
|
|
;; definition of type pull-rider-info
|
|
(deftype pull-rider-info (structure)
|
|
((rider collide-sticky-rider)
|
|
(rider-cshape collide-shape-moving)
|
|
(rider-delta-ry float)
|
|
(rider-dest vector :inline)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type pull-rider-info
|
|
(defmethod inspect ((this pull-rider-info))
|
|
(format #t "[~8x] ~A~%" this 'pull-rider-info)
|
|
(format #t "~Trider: #<collide-sticky-rider @ #x~X>~%" (-> this rider))
|
|
(format #t "~Trider-cshape: ~A~%" (-> this rider-cshape))
|
|
(format #t "~Trider-delta-ry: ~f~%" (-> this rider-delta-ry))
|
|
(format #t "~Trider-dest: #<vector @ #x~X>~%" (-> this rider-dest))
|
|
this
|
|
)
|
|
|
|
;; definition of type collide-shape-intersect
|
|
(deftype collide-shape-intersect (basic)
|
|
((move-vec vector :inline)
|
|
(best-u float)
|
|
(best-tri collide-tri-result :inline)
|
|
(best-from-prim collide-shape-prim)
|
|
(best-to-prim collide-shape-prim)
|
|
)
|
|
(:methods
|
|
(init! (_type_ vector) symbol)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-shape-intersect
|
|
(defmethod inspect ((this collide-shape-intersect))
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~Tmove-vec: ~`vector`P~%" (-> this move-vec))
|
|
(format #t "~Tbest-u: ~f~%" (-> this best-u))
|
|
(format #t "~Tbest-tri: #<collide-tri-result @ #x~X>~%" (-> this best-tri))
|
|
(format #t "~Tbest-from-prim: ~A~%" (-> this best-from-prim))
|
|
(format #t "~Tbest-to-prim: ~A~%" (-> this best-to-prim))
|
|
this
|
|
)
|
|
|
|
;; definition of type collide-overlap-result
|
|
(deftype collide-overlap-result (structure)
|
|
((best-dist float)
|
|
(best-from-prim collide-shape-prim)
|
|
(best-to-prim collide-shape-prim)
|
|
(best-from-tri collide-tri-result :inline)
|
|
)
|
|
(:methods
|
|
(reset! (_type_) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-overlap-result
|
|
(defmethod inspect ((this collide-overlap-result))
|
|
(format #t "[~8x] ~A~%" this 'collide-overlap-result)
|
|
(format #t "~Tbest-dist: ~f~%" (-> this best-dist))
|
|
(format #t "~Tbest-from-prim: ~A~%" (-> this best-from-prim))
|
|
(format #t "~Tbest-to-prim: ~A~%" (-> this best-to-prim))
|
|
(format #t "~Tbest-from-tri: #<collide-tri-result @ #x~X>~%" (-> this best-from-tri))
|
|
this
|
|
)
|
|
|
|
;; definition for method 9 of type collide-overlap-result
|
|
;; INFO: Return type mismatch symbol vs none.
|
|
(defmethod reset! ((this collide-overlap-result))
|
|
(set! (-> this best-dist) 0.0)
|
|
(set! (-> this best-from-prim) #f)
|
|
(set! (-> this best-to-prim) #f)
|
|
(none)
|
|
)
|
|
|
|
;; definition of type overlaps-others-params
|
|
(deftype overlaps-others-params (structure)
|
|
((options uint32)
|
|
(tlist touching-list)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type overlaps-others-params
|
|
(defmethod inspect ((this overlaps-others-params))
|
|
(format #t "[~8x] ~A~%" this 'overlaps-others-params)
|
|
(format #t "~Toptions: ~D~%" (-> this options))
|
|
(format #t "~Ttlist: ~A~%" (-> this tlist))
|
|
this
|
|
)
|
|
|
|
;; definition for symbol *collide-hit-by-player-list*, type engine
|
|
(define *collide-hit-by-player-list* (new 'global 'engine 'collide-hit-by-player-list 768))
|
|
|
|
;; definition for symbol *collide-usually-hit-by-player-list*, type engine
|
|
(define *collide-usually-hit-by-player-list* (new 'global 'engine 'collide-usually-hit-by-player-list 256))
|
|
|
|
;; definition for symbol *collide-hit-by-others-list*, type engine
|
|
(define *collide-hit-by-others-list* (new 'global 'engine 'collide-hit-by-others-list 96))
|
|
|
|
;; definition for symbol *collide-player-list*, type engine
|
|
(define *collide-player-list* (new 'global 'engine 'collide-player-list 32))
|
|
|
|
;; definition of type collide-prim-core
|
|
(deftype collide-prim-core (structure)
|
|
((world-sphere vector :inline)
|
|
(collide-as collide-kind)
|
|
(action collide-action)
|
|
(offense collide-offense)
|
|
(prim-type int8)
|
|
(extra uint8 2)
|
|
(quad uint128 2 :overlay-at (-> world-sphere quad))
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-prim-core
|
|
(defmethod inspect ((this collide-prim-core))
|
|
(format #t "[~8x] ~A~%" this 'collide-prim-core)
|
|
(format #t "~Tworld-sphere: ~`vector`P~%" (-> this world-sphere))
|
|
(format #t "~Tcollide-as: ~D~%" (-> this collide-as))
|
|
(format #t "~Taction: ~D~%" (-> this action))
|
|
(format #t "~Toffense: ~D~%" (-> this offense))
|
|
(format #t "~Tprim-type: ~D~%" (-> this prim-type))
|
|
(format #t "~Textra[2] @ #x~X~%" (-> this extra))
|
|
(format #t "~Tquad[2] @ #x~X~%" (-> this world-sphere))
|
|
this
|
|
)
|
|
|
|
;; definition of type collide-shape-prim
|
|
(deftype collide-shape-prim (basic)
|
|
((cshape collide-shape)
|
|
(prim-id uint32)
|
|
(transform-index int8)
|
|
(prim-core collide-prim-core :inline)
|
|
(local-sphere vector :inline)
|
|
(collide-with collide-kind)
|
|
(world-sphere vector :inline :overlay-at (-> prim-core world-sphere))
|
|
(collide-as collide-kind :overlay-at (-> prim-core collide-as))
|
|
(action collide-action :overlay-at (-> prim-core action))
|
|
(offense collide-offense :overlay-at (-> prim-core offense))
|
|
(prim-type int8 :overlay-at (-> prim-core prim-type))
|
|
(radius meters :overlay-at (-> local-sphere w))
|
|
)
|
|
(:methods
|
|
(new (symbol type collide-shape uint int) _type_)
|
|
(move-by-vector! (_type_ vector) none)
|
|
(find-prim-by-id (_type_ uint) collide-shape-prim)
|
|
(debug-draw-world-sphere (_type_) symbol)
|
|
(add-fg-prim-using-box (_type_ collide-cache) none)
|
|
(add-fg-prim-using-line-sphere (_type_ collide-cache) none)
|
|
(add-fg-prim-using-y-probe (_type_ collide-cache) none)
|
|
(overlaps-others-test (_type_ overlaps-others-params collide-shape-prim) symbol)
|
|
(overlaps-others-group (_type_ overlaps-others-params collide-shape-prim-group) symbol)
|
|
(unused-17 () none)
|
|
(collide-with-collide-cache-prim-mesh (_type_ collide-shape-intersect collide-cache-prim) none)
|
|
(collide-with-collide-cache-prim-sphere (_type_ collide-shape-intersect collide-cache-prim) none)
|
|
(add-to-bounding-box (_type_ collide-kind) symbol)
|
|
(num-mesh (_type_ collide-shape-prim) int)
|
|
(on-platform-test (_type_ collide-shape-prim collide-overlap-result float) none)
|
|
(should-push-away-test (_type_ collide-shape-prim collide-overlap-result) none)
|
|
(should-push-away-reverse-test (_type_ collide-shape-prim-group collide-overlap-result) none)
|
|
(update-transforms! (_type_ process-drawable) symbol)
|
|
(set-collide-as! (_type_ collide-kind) none)
|
|
(set-collide-with! (_type_ collide-kind) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-shape-prim
|
|
(defmethod inspect ((this collide-shape-prim))
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~Tcshape: ~A~%" (-> this cshape))
|
|
(format #t "~Tprim-id: #x~X~%" (-> this prim-id))
|
|
(format #t "~Ttransform-index: ~D~%" (-> this transform-index))
|
|
(format #t "~Tprim-core: #<collide-prim-core @ #x~X>~%" (-> this prim-core))
|
|
(format #t "~Tlocal-sphere: ~`vector`P~%" (-> this local-sphere))
|
|
(format #t "~Tcollide-with: ~D~%" (-> this collide-with))
|
|
(format #t "~Tworld-sphere: ~`vector`P~%" (-> this prim-core))
|
|
(format #t "~Tcollide-as: ~D~%" (-> this prim-core collide-as))
|
|
(format #t "~Taction: ~D~%" (-> this prim-core action))
|
|
(format #t "~Toffense: ~D~%" (-> this prim-core offense))
|
|
(format #t "~Tprim-type: ~D~%" (-> this prim-core prim-type))
|
|
(format #t "~Tradius: (meters ~m)~%" (-> this local-sphere w))
|
|
this
|
|
)
|
|
|
|
;; definition of type collide-shape-prim-sphere
|
|
(deftype collide-shape-prim-sphere (collide-shape-prim)
|
|
((pat pat-surface)
|
|
)
|
|
(:methods
|
|
(new (symbol type collide-shape uint) _type_)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-shape-prim-sphere
|
|
(defmethod inspect ((this collide-shape-prim-sphere))
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~Tcshape: ~A~%" (-> this cshape))
|
|
(format #t "~Tprim-id: #x~X~%" (-> this prim-id))
|
|
(format #t "~Ttransform-index: ~D~%" (-> this transform-index))
|
|
(format #t "~Tprim-core: #<collide-prim-core @ #x~X>~%" (-> this prim-core))
|
|
(format #t "~Tlocal-sphere: ~`vector`P~%" (-> this local-sphere))
|
|
(format #t "~Tcollide-with: ~D~%" (-> this collide-with))
|
|
(format #t "~Tworld-sphere: ~`vector`P~%" (-> this prim-core))
|
|
(format #t "~Tcollide-as: ~D~%" (-> this prim-core collide-as))
|
|
(format #t "~Taction: ~D~%" (-> this prim-core action))
|
|
(format #t "~Toffense: ~D~%" (-> this prim-core offense))
|
|
(format #t "~Tprim-type: ~D~%" (-> this prim-core prim-type))
|
|
(format #t "~Tradius: (meters ~m)~%" (-> this local-sphere w))
|
|
(format #t "~Tpat: ~D~%" (-> this pat))
|
|
this
|
|
)
|
|
|
|
;; definition of type collide-shape-prim-mesh
|
|
(deftype collide-shape-prim-mesh (collide-shape-prim)
|
|
((mesh collide-mesh)
|
|
(mesh-id int32)
|
|
(mesh-cache-id uint64)
|
|
(mesh-cache-tris (inline-array collide-mesh-cache-tri))
|
|
)
|
|
(:methods
|
|
(new (symbol type collide-shape uint uint) _type_)
|
|
(change-mesh (_type_ int) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-shape-prim-mesh
|
|
(defmethod inspect ((this collide-shape-prim-mesh))
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~Tcshape: ~A~%" (-> this cshape))
|
|
(format #t "~Tprim-id: #x~X~%" (-> this prim-id))
|
|
(format #t "~Ttransform-index: ~D~%" (-> this transform-index))
|
|
(format #t "~Tprim-core: #<collide-prim-core @ #x~X>~%" (-> this prim-core))
|
|
(format #t "~Tlocal-sphere: ~`vector`P~%" (-> this local-sphere))
|
|
(format #t "~Tcollide-with: ~D~%" (-> this collide-with))
|
|
(format #t "~Tworld-sphere: ~`vector`P~%" (-> this prim-core))
|
|
(format #t "~Tcollide-as: ~D~%" (-> this prim-core collide-as))
|
|
(format #t "~Taction: ~D~%" (-> this prim-core action))
|
|
(format #t "~Toffense: ~D~%" (-> this prim-core offense))
|
|
(format #t "~Tprim-type: ~D~%" (-> this prim-core prim-type))
|
|
(format #t "~Tradius: (meters ~m)~%" (-> this local-sphere w))
|
|
(format #t "~Tmesh: ~A~%" (-> this mesh))
|
|
(format #t "~Tmesh-id: ~D~%" (-> this mesh-id))
|
|
(format #t "~Tmesh-cache-id: ~D~%" (-> this mesh-cache-id))
|
|
(format #t "~Tmesh-cache-tris: #x~X~%" (-> this mesh-cache-tris))
|
|
this
|
|
)
|
|
|
|
;; definition of type collide-shape-prim-group
|
|
(deftype collide-shape-prim-group (collide-shape-prim)
|
|
((num-prims int32)
|
|
(num-prims-u uint32 :overlay-at num-prims)
|
|
(allocated-prims int32)
|
|
(prim collide-shape-prim 1)
|
|
(prims collide-shape-prim :dynamic :overlay-at (-> prim 0))
|
|
)
|
|
(:methods
|
|
(new (symbol type collide-shape uint int) _type_)
|
|
(append-prim (_type_ collide-shape-prim) none)
|
|
(add-to-non-empty-bounding-box (_type_ collide-kind) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-shape-prim-group
|
|
(defmethod inspect ((this collide-shape-prim-group))
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~Tcshape: ~A~%" (-> this cshape))
|
|
(format #t "~Tprim-id: #x~X~%" (-> this prim-id))
|
|
(format #t "~Ttransform-index: ~D~%" (-> this transform-index))
|
|
(format #t "~Tprim-core: #<collide-prim-core @ #x~X>~%" (-> this prim-core))
|
|
(format #t "~Tlocal-sphere: ~`vector`P~%" (-> this local-sphere))
|
|
(format #t "~Tcollide-with: ~D~%" (-> this collide-with))
|
|
(format #t "~Tworld-sphere: ~`vector`P~%" (-> this prim-core))
|
|
(format #t "~Tcollide-as: ~D~%" (-> this prim-core collide-as))
|
|
(format #t "~Taction: ~D~%" (-> this prim-core action))
|
|
(format #t "~Toffense: ~D~%" (-> this prim-core offense))
|
|
(format #t "~Tprim-type: ~D~%" (-> this prim-core prim-type))
|
|
(format #t "~Tradius: (meters ~m)~%" (-> this local-sphere w))
|
|
(format #t "~Tnum-prims: ~D~%" (-> this num-prims))
|
|
(format #t "~Tallocated-prims: ~D~%" (-> this allocated-prims))
|
|
(format #t "~Tprim[1] @ #x~X~%" (-> this prims))
|
|
this
|
|
)
|
|
|
|
;; definition of type collide-shape
|
|
(deftype collide-shape (trsqv)
|
|
((process process-drawable)
|
|
(max-iteration-count uint8)
|
|
(nav-flags nav-flags)
|
|
(pad-byte uint8 2)
|
|
(pat-ignore-mask pat-surface)
|
|
(event-self symbol)
|
|
(event-other symbol)
|
|
(root-prim collide-shape-prim)
|
|
(riders collide-sticky-rider-group)
|
|
(backup-collide-as collide-kind)
|
|
(backup-collide-with collide-kind)
|
|
)
|
|
(:methods
|
|
(new (symbol type process-drawable collide-list-enum) _type_)
|
|
(move-by-vector! (_type_ vector) none)
|
|
(alloc-riders (_type_ int) none)
|
|
(move-to-point! (_type_ vector) none)
|
|
(debug-draw (_type_) none)
|
|
(fill-cache-for-shape! (_type_ float collide-kind) none)
|
|
(fill-cache-integrate-and-collide! (_type_ vector collide-kind) none)
|
|
(find-prim-by-id (_type_ uint) collide-shape-prim)
|
|
(detect-riders! (_type_) symbol)
|
|
(build-bounding-box-for-shape (_type_ bounding-box float collide-kind) symbol)
|
|
(integrate-and-collide! (_type_ vector) none)
|
|
(find-collision-meshes (_type_) symbol)
|
|
(on-platform (_type_ collide-shape collide-overlap-result) symbol)
|
|
(find-overlapping-shapes (_type_ overlaps-others-params) symbol)
|
|
(calc-shove-up (_type_ attack-info float) vector)
|
|
(should-push-away (_type_ collide-shape collide-overlap-result) symbol)
|
|
(pull-rider! (_type_ pull-rider-info) none)
|
|
(pull-riders! (_type_) symbol)
|
|
(do-push-aways! (_type_) symbol)
|
|
(set-root-prim! (_type_ collide-shape-prim) collide-shape-prim)
|
|
(update-transforms! (_type_) symbol)
|
|
(clear-collide-with-as (_type_) none)
|
|
(restore-collide-with-as (_type_) none)
|
|
(backup-collide-with-as (_type_) none)
|
|
(set-root-prim-collide-with! (_type_ collide-kind) none)
|
|
(set-root-prim-collide-as! (_type_ collide-kind) none)
|
|
(set-collide-kinds (_type_ int collide-kind collide-kind) none)
|
|
(set-collide-offense (_type_ int collide-offense) none)
|
|
(send-shove-back (_type_ process touching-shapes-entry float float float) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-shape
|
|
(defmethod inspect ((this collide-shape))
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~Ttrans: ~`vector`P~%" (-> this trans))
|
|
(format #t "~Trot: ~`vector`P~%" (-> this quat))
|
|
(format #t "~Tscale: ~`vector`P~%" (-> this scale))
|
|
(format #t "~Tquat: #<quaternion @ #x~X>~%" (-> this quat))
|
|
(format #t "~Tpause-adjust-distance: (meters ~m)~%" (-> this pause-adjust-distance))
|
|
(format #t "~Tnav-radius: (meters ~m)~%" (-> this nav-radius))
|
|
(format #t "~Ttransv: ~`vector`P~%" (-> this transv))
|
|
(format #t "~Trotv: ~`vector`P~%" (-> this rotv))
|
|
(format #t "~Tscalev: ~`vector`P~%" (-> this scalev))
|
|
(format #t "~Tdir-targ: #<quaternion @ #x~X>~%" (-> this dir-targ))
|
|
(format #t "~Tangle-change-time: ~D~%" (-> this angle-change-time))
|
|
(format #t "~Told-y-angle-diff: ~f~%" (-> this old-y-angle-diff))
|
|
(format #t "~Tprocess: ~A~%" (-> this process))
|
|
(format #t "~Tmax-iteration-count: ~D~%" (-> this max-iteration-count))
|
|
(format #t "~Tnav-flags: ~D~%" (-> this nav-flags))
|
|
(format #t "~Tpad-byte[2] @ #x~X~%" (-> this pad-byte))
|
|
(format #t "~Tpat-ignore-mask: ~D~%" (-> this pat-ignore-mask))
|
|
(format #t "~Tevent-self: ~A~%" (-> this event-self))
|
|
(format #t "~Tevent-other: ~A~%" (-> this event-other))
|
|
(format #t "~Troot-prim: ~A~%" (-> this root-prim))
|
|
(format #t "~Triders: ~A~%" (-> this riders))
|
|
(format #t "~Tbackup-collide-as: ~D~%" (-> this backup-collide-as))
|
|
(format #t "~Tbackup-collide-with: ~D~%" (-> this backup-collide-with))
|
|
this
|
|
)
|
|
|
|
;; definition of type collide-shape-moving
|
|
(deftype collide-shape-moving (collide-shape)
|
|
((rider-time time-frame)
|
|
(rider-last-move vector :inline)
|
|
(trans-old vector 3 :inline)
|
|
(poly-pat pat-surface)
|
|
(cur-pat pat-surface)
|
|
(ground-pat pat-surface)
|
|
(status cshape-moving-flags)
|
|
(old-status cshape-moving-flags)
|
|
(prev-status cshape-moving-flags)
|
|
(reaction-flag cshape-reaction-flags)
|
|
(reaction (function collide-shape-moving collide-shape-intersect vector vector cshape-moving-flags))
|
|
(no-reaction (function collide-shape-moving collide-shape-intersect vector vector none))
|
|
(local-normal vector :inline)
|
|
(surface-normal vector :inline)
|
|
(poly-normal vector :inline)
|
|
(ground-poly-normal vector :inline)
|
|
(ground-touch-point vector :inline)
|
|
(shadow-pos vector :inline)
|
|
(ground-impact-vel meters)
|
|
(surface-angle float)
|
|
(poly-angle float)
|
|
(touch-angle float)
|
|
(coverage float)
|
|
(dynam dynamics)
|
|
(surf surface)
|
|
)
|
|
(:methods
|
|
(set-and-handle-pat! (_type_ pat-surface) none)
|
|
(integrate-no-collide! (_type_ vector) none)
|
|
(collide-shape-moving-method-58 (_type_ vector) symbol)
|
|
(integrate-for-enemy-with-move-to-ground! (_type_ vector collide-kind float symbol symbol symbol) none)
|
|
(move-to-ground (_type_ float float symbol collide-kind) symbol)
|
|
(move-to-ground-point! (_type_ vector vector vector) none)
|
|
(compute-acc-due-to-gravity (_type_ vector float) vector)
|
|
(step-collison! (_type_ vector vector float) float)
|
|
(move-to-tri! (_type_ collide-tri-result vector) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type collide-shape-moving
|
|
(defmethod inspect ((this collide-shape-moving))
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~Ttrans: ~`vector`P~%" (-> this trans))
|
|
(format #t "~Trot: ~`vector`P~%" (-> this quat))
|
|
(format #t "~Tscale: ~`vector`P~%" (-> this scale))
|
|
(format #t "~Tquat: #<quaternion @ #x~X>~%" (-> this quat))
|
|
(format #t "~Tpause-adjust-distance: (meters ~m)~%" (-> this pause-adjust-distance))
|
|
(format #t "~Tnav-radius: (meters ~m)~%" (-> this nav-radius))
|
|
(format #t "~Ttransv: ~`vector`P~%" (-> this transv))
|
|
(format #t "~Trotv: ~`vector`P~%" (-> this rotv))
|
|
(format #t "~Tscalev: ~`vector`P~%" (-> this scalev))
|
|
(format #t "~Tdir-targ: #<quaternion @ #x~X>~%" (-> this dir-targ))
|
|
(format #t "~Tangle-change-time: ~D~%" (-> this angle-change-time))
|
|
(format #t "~Told-y-angle-diff: ~f~%" (-> this old-y-angle-diff))
|
|
(format #t "~Tprocess: ~A~%" (-> this process))
|
|
(format #t "~Tmax-iteration-count: ~D~%" (-> this max-iteration-count))
|
|
(format #t "~Tnav-flags: ~D~%" (-> this nav-flags))
|
|
(format #t "~Tpad-byte[2] @ #x~X~%" (-> this pad-byte))
|
|
(format #t "~Tpat-ignore-mask: ~D~%" (-> this pat-ignore-mask))
|
|
(format #t "~Tevent-self: ~A~%" (-> this event-self))
|
|
(format #t "~Tevent-other: ~A~%" (-> this event-other))
|
|
(format #t "~Troot-prim: ~A~%" (-> this root-prim))
|
|
(format #t "~Triders: ~A~%" (-> this riders))
|
|
(format #t "~Tbackup-collide-as: ~D~%" (-> this backup-collide-as))
|
|
(format #t "~Tbackup-collide-with: ~D~%" (-> this backup-collide-with))
|
|
(format #t "~Trider-time: ~D~%" (-> this rider-time))
|
|
(format #t "~Trider-last-move: ~`vector`P~%" (-> this rider-last-move))
|
|
(format #t "~Ttrans-old[3] @ #x~X~%" (-> this trans-old))
|
|
(format #t "~Tpoly-pat: #x~X~%" (-> this poly-pat))
|
|
(format #t "~Tcur-pat: #x~X~%" (-> this cur-pat))
|
|
(format #t "~Tground-pat: #x~X~%" (-> this ground-pat))
|
|
(format #t "~Tstatus: ~D~%" (-> this status))
|
|
(format #t "~Told-status: ~D~%" (-> this old-status))
|
|
(format #t "~Tprev-status: ~D~%" (-> this prev-status))
|
|
(format #t "~Treaction-flag: ~D~%" (-> this reaction-flag))
|
|
(format #t "~Treaction: ~A~%" (-> this reaction))
|
|
(format #t "~Tno-reaction: ~A~%" (-> this no-reaction))
|
|
(format #t "~Tlocal-normal: ~`vector`P~%" (-> this local-normal))
|
|
(format #t "~Tsurface-normal: ~`vector`P~%" (-> this surface-normal))
|
|
(format #t "~Tpoly-normal: ~`vector`P~%" (-> this poly-normal))
|
|
(format #t "~Tground-poly-normal: ~`vector`P~%" (-> this ground-poly-normal))
|
|
(format #t "~Tground-touch-point: ~`vector`P~%" (-> this ground-touch-point))
|
|
(format #t "~Tshadow-pos: ~`vector`P~%" (-> this shadow-pos))
|
|
(format #t "~Tground-impact-vel: (meters ~m)~%" (-> this ground-impact-vel))
|
|
(format #t "~Tsurface-angle: ~f~%" (-> this surface-angle))
|
|
(format #t "~Tpoly-angle: ~f~%" (-> this poly-angle))
|
|
(format #t "~Ttouch-angle: ~f~%" (-> this touch-angle))
|
|
(format #t "~Tcoverage: ~f~%" (-> this coverage))
|
|
(format #t "~Tdynam: ~A~%" (-> this dynam))
|
|
(format #t "~Tsurf: ~A~%" (-> this surf))
|
|
this
|
|
)
|
|
|
|
;; definition for method 0 of type collide-shape-prim
|
|
(defmethod new collide-shape-prim ((allocation symbol) (type-to-make type) (cshape collide-shape) (prim-id uint) (size-bytes int))
|
|
(let ((v0-0 (object-new allocation type-to-make size-bytes)))
|
|
(set! (-> v0-0 cshape) cshape)
|
|
(set! (-> v0-0 prim-id) prim-id)
|
|
(set! (-> v0-0 prim-core action) (collide-action))
|
|
(set! (-> v0-0 prim-core collide-as) (collide-kind))
|
|
(set! (-> v0-0 collide-with) (collide-kind))
|
|
(set! (-> v0-0 transform-index) -2)
|
|
(set! (-> v0-0 prim-core offense) (collide-offense no-offense))
|
|
(set! (-> v0-0 prim-core prim-type) -2)
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 0 of type collide-shape-prim-sphere
|
|
;; INFO: Return type mismatch collide-shape-prim vs collide-shape-prim-sphere.
|
|
(defmethod new collide-shape-prim-sphere ((allocation symbol) (type-to-make type) (cshape collide-shape) (prim-id uint))
|
|
(let ((this (the-as
|
|
collide-shape-prim-sphere
|
|
((method-of-type collide-shape-prim new) allocation type-to-make cshape prim-id 76)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> this pat) (new 'static 'pat-surface :mode (pat-mode obstacle)))
|
|
(set! (-> this prim-core prim-type) -1)
|
|
(the-as collide-shape-prim-sphere this)
|
|
)
|
|
)
|
|
|
|
;; definition for method 0 of type collide-shape-prim-mesh
|
|
;; INFO: Return type mismatch collide-shape-prim vs collide-shape-prim-mesh.
|
|
(defmethod new collide-shape-prim-mesh ((allocation symbol) (type-to-make type) (cshape collide-shape) (mesh-id uint) (prim-id uint))
|
|
(let ((this (the-as
|
|
collide-shape-prim-mesh
|
|
((method-of-type collide-shape-prim new) allocation type-to-make cshape prim-id 92)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> this mesh) #f)
|
|
(set! (-> this mesh-id) (the-as int mesh-id))
|
|
(set! (-> this mesh-cache-id) (the-as uint 0))
|
|
(set! (-> this prim-core prim-type) 1)
|
|
(the-as collide-shape-prim-mesh this)
|
|
)
|
|
)
|
|
|
|
;; definition for method 0 of type collide-shape-prim-group
|
|
;; INFO: Return type mismatch collide-shape-prim vs collide-shape-prim-group.
|
|
(defmethod new collide-shape-prim-group ((allocation symbol) (type-to-make type) (cshape collide-shape) (elt-count uint) (prim-id int))
|
|
(let ((this (the-as collide-shape-prim-group ((method-of-type collide-shape-prim new)
|
|
allocation
|
|
type-to-make
|
|
cshape
|
|
(the-as uint prim-id)
|
|
(the-as int (+ (-> type-to-make size) (* (+ elt-count -1) 4)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> this allocated-prims) (the-as int elt-count))
|
|
(set! (-> this num-prims) 0)
|
|
(set! (-> this prim-core prim-type) 0)
|
|
(while (nonzero? elt-count)
|
|
(+! elt-count -1)
|
|
(set! (-> this prims elt-count) #f)
|
|
(nop!)
|
|
)
|
|
(the-as collide-shape-prim-group this)
|
|
)
|
|
)
|
|
|
|
;; definition for method 4 of type collide-shape-prim-group
|
|
(defmethod length ((this collide-shape-prim-group))
|
|
(-> this num-prims)
|
|
)
|
|
|
|
;; definition for method 5 of type collide-shape-prim-group
|
|
;; INFO: Return type mismatch uint vs int.
|
|
(defmethod asize-of ((this collide-shape-prim-group))
|
|
(the-as int (+ (-> this type size) (* (+ (-> this allocated-prims) -1) 4)))
|
|
)
|
|
|
|
;; definition for method 0 of type collide-shape
|
|
(defmethod new collide-shape ((allocation symbol) (type-to-make type) (proc process-drawable) (collide-list-kind collide-list-enum))
|
|
(let ((this (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> this process) proc)
|
|
(set! (-> this max-iteration-count) (the-as uint 1))
|
|
(set! (-> this nav-flags) (nav-flags navf0))
|
|
(set! (-> this event-self) #f)
|
|
(set! (-> this event-other) #f)
|
|
(set! (-> this riders) #f)
|
|
(set! (-> this root-prim) #f)
|
|
(case (-> proc type symbol)
|
|
(('camera)
|
|
(set! (-> this pat-ignore-mask) (new 'static 'pat-surface :nocamera #x1))
|
|
)
|
|
(else
|
|
(set! (-> this pat-ignore-mask) (new 'static 'pat-surface :noentity #x1))
|
|
)
|
|
)
|
|
(set! (-> this trans w) 1.0)
|
|
(quaternion-identity! (-> this quat))
|
|
(vector-identity! (-> this scale))
|
|
(cond
|
|
((= collide-list-kind (collide-list-enum hit-by-player))
|
|
(add-connection *collide-hit-by-player-list* proc #f this #f #f)
|
|
)
|
|
((= collide-list-kind (collide-list-enum usually-hit-by-player))
|
|
(add-connection *collide-usually-hit-by-player-list* proc #f this #f #f)
|
|
)
|
|
((= collide-list-kind (collide-list-enum hit-by-others))
|
|
(add-connection *collide-hit-by-others-list* proc #f this #f #f)
|
|
)
|
|
((= collide-list-kind (collide-list-enum player))
|
|
(add-connection *collide-player-list* proc #f this #f #f)
|
|
)
|
|
(else
|
|
(format 0 "Unsupported collide-list-enum in collide-shape constructor!~%")
|
|
)
|
|
)
|
|
this
|
|
)
|
|
)
|
|
|
|
;; definition for method 0 of type collide-sticky-rider-group
|
|
(defmethod new collide-sticky-rider-group ((allocation symbol) (type-to-make type) (arg0 int))
|
|
(let ((this (object-new allocation type-to-make (the-as int (+ (-> type-to-make size) (* (+ arg0 -1) 32))))))
|
|
(set! (-> this allocated-riders) arg0)
|
|
(set! (-> this num-riders) 0)
|
|
this
|
|
)
|
|
)
|
|
|
|
;; definition for method 4 of type collide-sticky-rider-group
|
|
(defmethod length ((this collide-sticky-rider-group))
|
|
(-> this num-riders)
|
|
)
|
|
|
|
;; definition for method 5 of type collide-sticky-rider-group
|
|
;; INFO: Return type mismatch uint vs int.
|
|
(defmethod asize-of ((this collide-sticky-rider-group))
|
|
(the-as int (+ (-> this type size) (* (+ (-> this allocated-riders) -1) 32)))
|
|
)
|
|
|
|
;; definition for symbol *collide-shape-prim-backgnd*, type collide-shape-prim-mesh
|
|
(define *collide-shape-prim-backgnd* (new 'static 'collide-shape-prim-mesh
|
|
:cshape #f
|
|
:prim-core (new 'static 'collide-prim-core
|
|
:world-sphere (new 'static 'vector :w 204800000.0)
|
|
:collide-as (collide-kind background)
|
|
:action (collide-action solid)
|
|
:offense (collide-offense indestructible)
|
|
:prim-type 2
|
|
)
|
|
:local-sphere (new 'static 'vector :w 204800000.0)
|
|
:mesh #f
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *collide-shape-prim-water*, type collide-shape-prim-mesh
|
|
(define *collide-shape-prim-water* (new 'static 'collide-shape-prim-mesh
|
|
:cshape #f
|
|
:prim-core (new 'static 'collide-prim-core
|
|
:world-sphere (new 'static 'vector :w 204800000.0)
|
|
:collide-as (collide-kind water)
|
|
:action (collide-action solid)
|
|
:offense (collide-offense indestructible)
|
|
:prim-type 2
|
|
)
|
|
:local-sphere (new 'static 'vector :w 204800000.0)
|
|
:mesh #f
|
|
)
|
|
)
|