mirror of
https://github.com/open-goal/jak-project
synced 2026-06-16 14:50:32 -04:00
Tyler Wilding
1571 lines
56 KiB
Common Lisp
Vendored
Generated
1571 lines
56 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type rigid-body-work
|
|
(deftype rigid-body-work (structure)
|
|
((max-ang-momentum float)
|
|
(max-ang-velocity float)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type rigid-body-work
|
|
(defmethod inspect ((this rigid-body-work))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" this 'rigid-body-work)
|
|
(format #t "~1Tmax-ang-momentum: ~f~%" (-> this max-ang-momentum))
|
|
(format #t "~1Tmax-ang-velocity: ~f~%" (-> this max-ang-velocity))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for symbol *rigid-body-work*, type rigid-body-work
|
|
(define *rigid-body-work* (new 'static 'rigid-body-work))
|
|
|
|
;; definition for method 0 of type rigid-body-control
|
|
(defmethod new rigid-body-control ((allocation symbol) (type-to-make type) (arg0 process))
|
|
(let ((v0-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> v0-0 process) arg0)
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 7 of type rigid-body-control
|
|
(defmethod relocate ((this rigid-body-control) (offset int))
|
|
(&+! (-> this process) offset)
|
|
this
|
|
)
|
|
|
|
;; definition for method 9 of type rigid-body-info
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-info-method-9 ((this rigid-body-info))
|
|
(let ((f24-0 (-> this mass))
|
|
(f28-0 (-> this inertial-tensor-box 0))
|
|
(f30-0 (-> this inertial-tensor-box 1))
|
|
(f26-0 (-> this inertial-tensor-box 2))
|
|
)
|
|
(let ((f0-0 f24-0))
|
|
(set! (-> this inv-mass) (/ 1.0 f0-0))
|
|
)
|
|
(matrix-identity! (-> this inertial-tensor))
|
|
(matrix-identity! (-> this inv-inertial-tensor))
|
|
(let ((f0-4 (* 0.083333336 f24-0)))
|
|
(let* ((f1-1 f30-0)
|
|
(f1-3 (* f1-1 f1-1))
|
|
(f2-0 f26-0)
|
|
)
|
|
(set! (-> this inertial-tensor vector 0 x) (* f0-4 (+ f1-3 (* f2-0 f2-0))))
|
|
)
|
|
(let ((f1-6 f28-0))
|
|
(set! (-> this inertial-tensor vector 1 y) (* f0-4 (+ (* f1-6 f1-6) (* f26-0 f26-0))))
|
|
)
|
|
(set! (-> this inertial-tensor vector 2 z) (* f0-4 (+ (* f28-0 f28-0) (* f30-0 f30-0))))
|
|
)
|
|
)
|
|
(let ((f0-6 (-> this inertial-tensor vector 0 x)))
|
|
(set! (-> this inv-inertial-tensor vector 0 x) (/ 1.0 f0-6))
|
|
)
|
|
(let ((f0-9 (-> this inertial-tensor vector 1 y)))
|
|
(set! (-> this inv-inertial-tensor vector 1 y) (/ 1.0 f0-9))
|
|
)
|
|
(let ((f0-12 (-> this inertial-tensor vector 2 z)))
|
|
(set! (-> this inv-inertial-tensor vector 2 z) (/ 1.0 f0-12))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 16 of type rigid-body
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod clear-force-torque! ((this rigid-body))
|
|
(set! (-> this force quad) (the-as uint128 0))
|
|
(set! (-> this torque quad) (the-as uint128 0))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 17 of type rigid-body
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod clear-momentum! ((this rigid-body))
|
|
(set! (-> this lin-momentum quad) (the-as uint128 0))
|
|
(set! (-> this ang-momentum quad) (the-as uint128 0))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 24 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-24 ((this rigid-body))
|
|
(when #t
|
|
(quaternion->matrix (-> this matrix) (-> this rotation))
|
|
(let ((s5-0 (new 'stack-no-clear 'vector)))
|
|
(vector-rotate*! s5-0 (-> this info cm-offset-joint) (-> this matrix))
|
|
(vector-! (-> this matrix trans) (-> this position) s5-0)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 26 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-26 ((this rigid-body) (arg0 vector) (arg1 quaternion))
|
|
(let ((s3-0 (new 'stack-no-clear 'inline-array 'vector 8)))
|
|
(quaternion->matrix (the-as matrix (-> s3-0 1)) arg1)
|
|
(vector-rotate*! (-> s3-0 0) (-> this info cm-offset-joint) (the-as matrix (-> s3-0 1)))
|
|
(vector+! (-> this position) arg0 (-> s3-0 0))
|
|
)
|
|
(quaternion-copy! (-> this rotation) arg1)
|
|
(quaternion-normalize! (-> this rotation))
|
|
(rigid-body-method-24 this)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 25 of type rigid-body
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-25 ((this rigid-body) (arg0 rigid-body-info) (arg1 vector) (arg2 quaternion) (arg3 function))
|
|
(set! (-> this work) *rigid-body-work*)
|
|
(set! (-> this info) arg0)
|
|
(set! (-> this force-callback) (the-as (function object float none) arg3))
|
|
(rigid-body-info-method-9 (-> this info))
|
|
(let ((v1-3 this))
|
|
(set! (-> v1-3 force quad) (the-as uint128 0))
|
|
(set! (-> v1-3 torque quad) (the-as uint128 0))
|
|
)
|
|
0
|
|
(clear-momentum! this)
|
|
(rigid-body-method-26 this arg1 arg2)
|
|
(rigid-body-method-13 this)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 22 of type rigid-body
|
|
(defmethod rigid-body-method-22 ((this rigid-body) (arg0 vector) (arg1 vector))
|
|
(let ((v1-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> this position))))
|
|
(vector-cross! arg1 (-> this ang-velocity) v1-1)
|
|
)
|
|
(vector+! arg1 arg1 (-> this lin-velocity))
|
|
arg1
|
|
)
|
|
|
|
;; definition for function matrix-3x3-triple-transpose-product
|
|
;; INFO: Used lq/sq
|
|
(defun matrix-3x3-triple-transpose-product ((arg0 matrix) (arg1 matrix) (arg2 matrix))
|
|
(let ((s5-0 (new 'stack-no-clear 'inline-array 'matrix 3)))
|
|
(let* ((v1-0 (-> s5-0 0))
|
|
(a3-0 arg1)
|
|
(a0-1 (-> a3-0 quad 0))
|
|
(a1-1 (-> a3-0 quad 1))
|
|
(a2-1 (-> a3-0 quad 2))
|
|
(a3-1 (-> a3-0 trans quad))
|
|
)
|
|
(set! (-> v1-0 quad 0) a0-1)
|
|
(set! (-> v1-0 quad 1) a1-1)
|
|
(set! (-> v1-0 quad 2) a2-1)
|
|
(set! (-> v1-0 trans quad) a3-1)
|
|
)
|
|
(vector-reset! (-> s5-0 0 trans))
|
|
(matrix-transpose! (-> s5-0 1) (-> s5-0 0))
|
|
(matrix*! (-> s5-0 2) arg2 (-> s5-0 0))
|
|
(matrix*! arg0 (-> s5-0 1) (-> s5-0 2))
|
|
)
|
|
arg0
|
|
)
|
|
|
|
;; definition for method 12 of type rigid-body
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-12 ((this rigid-body) (arg0 float))
|
|
(local-vars (v1-6 float))
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf1 :class vf)
|
|
(vf2 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
(vf6 :class vf)
|
|
(vf7 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((a2-0 (-> this lin-momentum)))
|
|
(let ((v1-0 (-> this lin-momentum)))
|
|
(let ((a0-1 (-> this force)))
|
|
(let ((a3-0 arg0))
|
|
(.mov vf7 a3-0)
|
|
)
|
|
(.lvf vf5 (&-> a0-1 quad))
|
|
)
|
|
(.lvf vf4 (&-> v1-0 quad))
|
|
)
|
|
(.add.x.vf vf6 vf0 vf0 :mask #b1000)
|
|
(.mul.x.vf acc vf5 vf7 :mask #b111)
|
|
(.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
|
|
(.svf (&-> a2-0 quad) vf6)
|
|
)
|
|
(let ((a2-1 (-> this ang-momentum)))
|
|
(let ((v1-1 (-> this ang-momentum)))
|
|
(let ((a0-2 (-> this torque)))
|
|
(let ((a1-1 arg0))
|
|
(.mov vf7 a1-1)
|
|
)
|
|
(.lvf vf5 (&-> a0-2 quad))
|
|
)
|
|
(.lvf vf4 (&-> v1-1 quad))
|
|
)
|
|
(.add.x.vf vf6 vf0 vf0 :mask #b1000)
|
|
(.mul.x.vf acc vf5 vf7 :mask #b111)
|
|
(.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
|
|
(.svf (&-> a2-1 quad) vf6)
|
|
)
|
|
(let* ((f0-3 (* 500000000.0 (-> this info mass)))
|
|
(f1-1 f0-3)
|
|
(f1-3 (* f1-1 f1-1))
|
|
)
|
|
(.lvf vf1 (&-> (-> this ang-momentum) quad))
|
|
(.add.w.vf vf2 vf0 vf0 :mask #b1)
|
|
(.mul.vf vf1 vf1 vf1)
|
|
(.mul.x.vf acc vf2 vf1 :mask #b1)
|
|
(.add.mul.y.vf acc vf2 vf1 acc :mask #b1)
|
|
(.add.mul.z.vf vf1 vf2 vf1 acc :mask #b1)
|
|
(.mov v1-6 vf1)
|
|
(if (< f1-3 v1-6)
|
|
(vector-normalize! (-> this ang-momentum) f0-3)
|
|
)
|
|
)
|
|
(set! (-> this force quad) (the-as uint128 0))
|
|
(set! (-> this torque quad) (the-as uint128 0))
|
|
0
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 13 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-13 ((this rigid-body))
|
|
(let ((v1-0 (-> this info)))
|
|
(vector-float*! (-> this lin-velocity) (-> this lin-momentum) (-> v1-0 inv-mass))
|
|
(matrix-3x3-triple-transpose-product (-> this inv-i-world) (-> this matrix) (-> v1-0 inv-inertial-tensor))
|
|
)
|
|
(vector-rotate*! (-> this ang-velocity) (-> this ang-momentum) (-> this inv-i-world))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 14 of type rigid-body
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-14 ((this rigid-body) (arg0 float))
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
(vf6 :class vf)
|
|
(vf7 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((a1-1 (-> this position)))
|
|
(let ((v1-0 (-> this position)))
|
|
(let ((a0-1 (-> this lin-velocity)))
|
|
(let ((a2-0 arg0))
|
|
(.mov vf7 a2-0)
|
|
)
|
|
(.lvf vf5 (&-> a0-1 quad))
|
|
)
|
|
(.lvf vf4 (&-> v1-0 quad))
|
|
)
|
|
(.add.x.vf vf6 vf0 vf0 :mask #b1000)
|
|
(.mul.x.vf acc vf5 vf7 :mask #b111)
|
|
(.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
|
|
(.svf (&-> a1-1 quad) vf6)
|
|
)
|
|
(let ((s4-0 (new 'stack-no-clear 'quaternion)))
|
|
(set! (-> (the-as vector (&-> s4-0 x)) quad) (-> this ang-velocity quad))
|
|
(set! (-> s4-0 w) 0.0)
|
|
(quaternion*! s4-0 s4-0 (-> this rotation))
|
|
(quaternion-float*! s4-0 s4-0 0.5)
|
|
(+! (-> this rotation x) (* (-> s4-0 x) arg0))
|
|
(+! (-> this rotation y) (* (-> s4-0 y) arg0))
|
|
(+! (-> this rotation z) (* (-> s4-0 z) arg0))
|
|
(+! (-> this rotation w) (* (-> s4-0 w) arg0))
|
|
)
|
|
(quaternion-normalize! (-> this rotation))
|
|
(rigid-body-method-24 this)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for function damping-time-adjust
|
|
(defun damping-time-adjust ((arg0 float) (arg1 float))
|
|
(let ((f0-0 0.0)
|
|
(f1-0 1.0)
|
|
(f2-2 (* (+ -1.0 arg0) arg1))
|
|
(f3-2 0.016666668)
|
|
)
|
|
(fmax f0-0 (+ f1-0 (* f2-2 (/ 1.0 f3-2))))
|
|
)
|
|
)
|
|
|
|
;; definition for method 9 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-9 ((this rigid-body) (arg0 collide-shape-moving) (arg1 float))
|
|
(rigid-body-method-12 this arg1)
|
|
(let ((v1-2 (-> this info)))
|
|
(let* ((a0-2 (-> this lin-momentum))
|
|
(a1-2 (-> this lin-momentum))
|
|
(f3-0 (-> v1-2 linear-damping))
|
|
(f2-0 arg1)
|
|
(f0-0 0.0)
|
|
(f1-0 1.0)
|
|
(f2-1 (* (+ -1.0 f3-0) f2-0))
|
|
(f3-2 0.016666668)
|
|
)
|
|
(vector-float*! a0-2 a1-2 (fmax f0-0 (+ f1-0 (* f2-1 (/ 1.0 f3-2)))))
|
|
)
|
|
(let* ((a0-4 (-> this ang-momentum))
|
|
(a1-3 (-> this ang-momentum))
|
|
(f3-5 (-> v1-2 angular-damping))
|
|
(f2-3 arg1)
|
|
(f0-3 0.0)
|
|
(f1-2 1.0)
|
|
(f2-4 (* (+ -1.0 f3-5) f2-3))
|
|
(f3-7 0.016666668)
|
|
)
|
|
(vector-float*! a0-4 a1-3 (fmax f0-3 (+ f1-2 (* f2-4 (/ 1.0 f3-7)))))
|
|
)
|
|
)
|
|
(rigid-body-method-13 this)
|
|
(if (logtest? (-> this flags) (rigid-body-flag enable-collision))
|
|
(collide-shape-moving-method-63 arg0 this arg1)
|
|
(rigid-body-method-14 this arg1)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 67 of type collide-shape-moving
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod collide-with-all-collide-cache-prims ((this collide-shape-moving) (arg0 matrix) (arg1 collide-query))
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf1 :class vf)
|
|
(vf2 :class vf)
|
|
(vf3 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
(vf6 :class vf)
|
|
(vf7 :class vf)
|
|
(vf8 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((s4-0 *collide-cache*)
|
|
(s3-0 (-> this root-prim))
|
|
(s2-0 1)
|
|
)
|
|
(b! (nonzero? (-> s3-0 prim-core prim-type)) cfg-2 :delay (empty-form))
|
|
(let ((v1-2 s3-0))
|
|
(set! s3-0 (-> (the-as collide-shape-prim-group v1-2) child 0))
|
|
(set! s2-0 (the-as int (-> v1-2 specific 0)))
|
|
)
|
|
(label cfg-2)
|
|
(b! #t cfg-13 :delay (nop!))
|
|
(label cfg-3)
|
|
(+! s2-0 -1)
|
|
(let ((v1-4 -1))
|
|
(b! (!= (-> s3-0 prim-core prim-type) v1-4) cfg-12 :delay (nop!))
|
|
)
|
|
(.lvf vf5 (&-> s3-0 local-sphere quad))
|
|
(.lvf vf1 (&-> arg0 quad 0))
|
|
(.lvf vf2 (&-> arg0 quad 1))
|
|
(.lvf vf3 (&-> arg0 quad 2))
|
|
(.lvf vf4 (&-> arg0 trans quad))
|
|
(.lvf vf6 (&-> s3-0 prim-core world-sphere quad))
|
|
(.mul.x.vf acc vf1 vf5)
|
|
(.add.mul.y.vf acc vf2 vf5 acc)
|
|
(.add.mul.z.vf acc vf3 vf5 acc)
|
|
(.add.mul.w.vf vf7 vf4 vf0 acc :mask #b111)
|
|
(.sub.vf vf8 vf7 vf6 :mask #b111)
|
|
(.svf (&-> arg1 move-dist quad) vf8)
|
|
(let ((s1-0 (the-as collide-cache-prim (-> s4-0 prims))))
|
|
(countdown (s0-0 (-> s4-0 num-prims))
|
|
(when (logtest? (-> s3-0 prim-core collide-with) (-> s1-0 prim-core collide-as))
|
|
(if (>= (the-as int (-> s1-0 prim-core prim-type)) 0)
|
|
(collide-with-collide-cache-prim-mesh s3-0 arg1 s1-0)
|
|
(collide-with-collide-cache-prim-sphere s3-0 arg1 s1-0)
|
|
)
|
|
)
|
|
(&+! s1-0 48)
|
|
)
|
|
)
|
|
(label cfg-12)
|
|
(&+! s3-0 80)
|
|
(label cfg-13)
|
|
(b! (nonzero? s2-0) cfg-3 :delay (nop!))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for function transform-rigid-body-prims
|
|
(defun transform-rigid-body-prims ((arg0 collide-shape-prim) (arg1 matrix))
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf1 :class vf)
|
|
(vf2 :class vf)
|
|
(vf3 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((v1-0 arg0)
|
|
(a0-1 1)
|
|
)
|
|
(when (= (-> v1-0 prim-core prim-type) (prim-type group))
|
|
(let ((a0-2 (the-as collide-shape-prim-group v1-0)))
|
|
(set! v1-0 (-> a0-2 child 0))
|
|
(set! a0-1 (the-as int (-> a0-2 num-children)))
|
|
)
|
|
)
|
|
(while (nonzero? a0-1)
|
|
(+! a0-1 -1)
|
|
(.lvf vf5 (&-> v1-0 local-sphere quad))
|
|
(.lvf vf1 (&-> arg1 quad 0))
|
|
(.lvf vf2 (&-> arg1 quad 1))
|
|
(.lvf vf3 (&-> arg1 quad 2))
|
|
(.lvf vf4 (&-> arg1 trans quad))
|
|
(.mul.x.vf acc vf1 vf5)
|
|
(.add.mul.y.vf acc vf2 vf5 acc)
|
|
(.add.mul.z.vf acc vf3 vf5 acc)
|
|
(.add.mul.w.vf vf5 vf4 vf0 acc :mask #b111)
|
|
(.svf (&-> v1-0 prim-core world-sphere quad) vf5)
|
|
(&+! v1-0 80)
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
|
|
;; definition for method 63 of type collide-shape-moving
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod collide-shape-moving-method-63 ((this collide-shape-moving) (arg0 rigid-body) (arg1 float))
|
|
(local-vars (s3-0 rigid-body))
|
|
(with-pp
|
|
(rlet ((acc :class vf)
|
|
(Q :class vf)
|
|
(vf0 :class vf)
|
|
(vf6 :class vf)
|
|
(vf7 :class vf)
|
|
(vf8 :class vf)
|
|
(vf9 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((s5-0 (new 'stack-no-clear 'rb-work)))
|
|
(set! (-> s5-0 dt) arg1)
|
|
(set! (-> s5-0 float-1) 1.0)
|
|
(set! (-> s5-0 cnt) 0)
|
|
(until (not (and (< 0.05 (-> s5-0 float-1)) (< (-> s5-0 cnt) (the-as int (-> this max-iteration-count)))))
|
|
(set! (-> s5-0 cquery best-dist) -100000000.0)
|
|
(set! (-> s5-0 cquery best-my-prim) #f)
|
|
(set! (-> s5-0 cquery num-spheres) (the-as uint #f))
|
|
(set! (-> s5-0 vec-1 quad) (-> arg0 position quad))
|
|
(quaternion-copy! (-> s5-0 quat-1) (-> arg0 rotation))
|
|
(rigid-body-method-14 arg0 (* (-> s5-0 float-1) (-> s5-0 dt)))
|
|
(mem-copy! (the-as pointer (-> s5-0 mat-1)) (the-as pointer (-> arg0 matrix)) 64)
|
|
(set! (-> arg0 position quad) (-> s5-0 vec-1 quad))
|
|
(quaternion-copy! (-> arg0 rotation) (-> s5-0 quat-1))
|
|
(rigid-body-method-24 arg0)
|
|
(transform-rigid-body-prims (-> this root-prim) (-> arg0 matrix))
|
|
(collide-with-all-collide-cache-prims this (-> s5-0 mat-1) (-> s5-0 cquery))
|
|
(let ((f30-0 (-> s5-0 cquery best-dist)))
|
|
(b! (>= f30-0 0.0) cfg-3 :delay #f)
|
|
(rigid-body-method-14 arg0 (* (-> s5-0 float-1) (-> s5-0 dt)))
|
|
(rigid-body-method-13 arg0)
|
|
(transform-rigid-body-prims (-> this root-prim) (-> arg0 matrix))
|
|
(set! (-> s5-0 float-1) 0.0)
|
|
(b! #t cfg-44 :delay (nop!))
|
|
(label cfg-3)
|
|
(update-from-step-size *touching-list* f30-0)
|
|
(rigid-body-method-14 arg0 (* (-> s5-0 float-1) (-> s5-0 dt) f30-0))
|
|
)
|
|
(rigid-body-method-13 arg0)
|
|
(transform-rigid-body-prims (-> this root-prim) (-> arg0 matrix))
|
|
(mem-copy! (the-as pointer (-> s5-0 mat-1)) (the-as pointer (-> arg0 matrix)) 64)
|
|
(set! s3-0 (the-as rigid-body #f))
|
|
(b! (not (-> s5-0 cquery num-spheres)) cfg-12 :delay (empty-form))
|
|
(let ((a0-20 (-> (the-as collide-shape-prim (-> s5-0 cquery num-spheres)) cshape process)))
|
|
(b! (zero? (-> a0-20 rbody)) cfg-12 :delay (empty-form))
|
|
(set! s3-0 (-> a0-20 rbody state))
|
|
(b! (not (logtest? (-> s3-0 flags) (rigid-body-flag active))) cfg-11 :delay (nop!))
|
|
(b! (logtest? (-> s3-0 flags) (rigid-body-flag enable-physics)) cfg-10 :delay (empty-form))
|
|
(send-event a0-20 'enable-physics)
|
|
)
|
|
(label cfg-10)
|
|
(b! #t cfg-12 :delay (nop!))
|
|
(label cfg-11)
|
|
(set! s3-0 (the-as rigid-body #f))
|
|
(label cfg-12)
|
|
(let ((v1-37 (-> s5-0 cquery best-my-prim)))
|
|
(.lvf vf7 (&-> (-> s5-0 cquery) best-other-tri intersect quad))
|
|
(.lvf vf6 (&-> v1-37 prim-core world-sphere quad))
|
|
(.sub.vf vf8 vf6 vf7)
|
|
(.mul.vf vf9 vf8 vf8 :mask #b111)
|
|
(.mul.x.vf acc vf0 vf9 :mask #b1000)
|
|
(.add.mul.y.vf acc vf0 vf9 acc :mask #b1000)
|
|
(.add.mul.z.vf vf9 vf0 vf9 acc :mask #b1000)
|
|
(.isqrt.vf Q vf0 vf9 :fsf #b11 :ftf #b11)
|
|
(.mov.vf vf8 vf0 :mask #b1000)
|
|
(.wait.vf)
|
|
(.mul.vf vf8 vf8 Q :mask #b111)
|
|
(.nop.vf)
|
|
(.nop.vf)
|
|
(.nop.vf)
|
|
(.svf (&-> s5-0 vec-5 quad) vf8)
|
|
(.svf (&-> s5-0 vec-2 quad) vf7)
|
|
(set! (-> s5-0 prim-id) (the-as int (-> v1-37 prim-id)))
|
|
)
|
|
(rigid-body-method-22 arg0 (-> s5-0 vec-2) (-> s5-0 vec-3))
|
|
(b! (not s3-0) cfg-14 :delay (empty-form))
|
|
(rigid-body-method-13 s3-0)
|
|
(rigid-body-method-22 s3-0 (-> s5-0 vec-2) (-> s5-0 vec-4))
|
|
(vector-! (-> s5-0 vec-3) (-> s5-0 vec-3) (-> s5-0 vec-4))
|
|
(label cfg-14)
|
|
(set! (-> s5-0 float-4) 0.0)
|
|
(set! (-> s5-0 float-2) (+ -409.6 (vector-dot (-> s5-0 vec-3) (-> s5-0 vec-5))))
|
|
(set! (-> s5-0 float-3) 0.0)
|
|
(b! (>= (-> s5-0 float-2) 0.0) cfg-39)
|
|
(vector-! (-> s5-0 vec-6) (-> s5-0 vec-2) (-> arg0 position))
|
|
(vector-cross! (-> s5-0 vec-7) (-> s5-0 vec-6) (-> s5-0 vec-5))
|
|
(vector-rotate*! (-> s5-0 vec-7) (-> s5-0 vec-7) (-> arg0 inv-i-world))
|
|
(vector-cross! (-> s5-0 vec-7) (-> s5-0 vec-7) (-> s5-0 vec-6))
|
|
(set! (-> s5-0 float-3) (+ (-> arg0 info inv-mass) (vector-dot (-> s5-0 vec-5) (-> s5-0 vec-7))))
|
|
(let ((f30-1 (-> arg0 info bounce-factor)))
|
|
(cond
|
|
(s3-0
|
|
(vector-! (-> s5-0 vec-6) (-> s5-0 vec-2) (-> s3-0 position))
|
|
(vector-cross! (-> s5-0 vec-7) (-> s5-0 vec-6) (-> s5-0 vec-5))
|
|
(vector-rotate*! (-> s5-0 vec-7) (-> s5-0 vec-7) (-> s3-0 inv-i-world))
|
|
(vector-cross! (-> s5-0 vec-7) (-> s5-0 vec-7) (-> s5-0 vec-6))
|
|
(+! (-> s5-0 float-3) (+ (-> s3-0 info inv-mass) (vector-dot (-> s5-0 vec-5) (-> s5-0 vec-7))))
|
|
(set! f30-1
|
|
(fmax
|
|
(fmax f30-1 (-> s3-0 info bounce-factor))
|
|
(* (-> arg0 info bounce-mult-factor) (-> s3-0 info bounce-mult-factor))
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
)
|
|
)
|
|
(set! (-> s5-0 float-4) (* (+ 1.0 f30-1) (/ (- (-> s5-0 float-2)) (-> s5-0 float-3))))
|
|
)
|
|
(vector-float*! (-> s5-0 vec-8) (-> s5-0 vec-5) (-> s5-0 float-4))
|
|
(let ((f30-2 (-> arg0 info mass)))
|
|
(if s3-0
|
|
(set! f30-2 (fmin f30-2 (-> s3-0 info mass)))
|
|
)
|
|
(vector+float*! (-> s5-0 vec-9) (-> s5-0 vec-3) (-> s5-0 vec-5) (- (-> s5-0 float-2)))
|
|
(vector-normalize! (-> s5-0 vec-9) 1.0)
|
|
(let ((f0-31
|
|
(* -1.0
|
|
(fmin
|
|
(* (vector-dot (-> s5-0 vec-9) (-> s5-0 vec-3)) f30-2)
|
|
(* (-> arg0 info friction-factor) (-> s5-0 float-4))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(vector+float*! (-> s5-0 vec-8) (-> s5-0 vec-8) (-> s5-0 vec-9) f0-31)
|
|
)
|
|
)
|
|
(rigid-body-method-18 arg0 (-> s5-0 vec-2) (-> s5-0 vec-8))
|
|
(when s3-0
|
|
(vector-float*! (-> s5-0 vec-8) (-> s5-0 vec-8) -1.0)
|
|
(rigid-body-method-18 s3-0 (-> s5-0 vec-2) (-> s5-0 vec-8))
|
|
)
|
|
(rigid-body-method-12 arg0 1.0)
|
|
(rigid-body-method-13 arg0)
|
|
(let ((f30-3 (-> s5-0 cquery best-dist)))
|
|
(when (< f30-3 0.0001)
|
|
(vector+float*! (-> arg0 position) (-> arg0 position) (-> s5-0 vec-5) 40.96)
|
|
(rigid-body-method-24 arg0)
|
|
)
|
|
(set! (-> s5-0 float-1) (- (-> s5-0 float-1) (* f30-3 (-> s5-0 float-1))))
|
|
)
|
|
(set! (-> s5-0 pat-id) (-> s5-0 cquery best-other-tri pat))
|
|
(let ((v1-103 pp))
|
|
(let ((a0-49 (the-as object (-> s5-0 cquery num-spheres))))
|
|
(if (the-as uint a0-49)
|
|
(set! v1-103 (-> (the-as collide-shape-prim-mesh a0-49) cshape process))
|
|
)
|
|
)
|
|
(set! (-> s5-0 rbody) s3-0)
|
|
(send-event (-> this process) 'impact-impulse :from v1-103 (-> s5-0 vec-2))
|
|
)
|
|
(b! (not s3-0) cfg-32 :delay (empty-form))
|
|
(rigid-body-method-12 s3-0 1.0)
|
|
(rigid-body-method-13 s3-0)
|
|
(let ((s2-0 (-> (the-as collide-shape-prim-mesh (-> s5-0 cquery num-spheres)) cshape)))
|
|
(transform-rigid-body-prims (-> s2-0 root-prim) (-> s3-0 matrix))
|
|
(vector-float*! (-> s5-0 vec-5) (-> s5-0 vec-5) -1.0)
|
|
(vector-float*! (-> s5-0 vec-3) (-> s5-0 vec-3) -1.0)
|
|
(set! (-> s5-0 rbody) arg0)
|
|
(send-event (-> s2-0 process) 'impact-impulse :from (-> this process) (-> s5-0 vec-2))
|
|
)
|
|
(label cfg-32)
|
|
(+! (-> s5-0 cnt) 1)
|
|
)
|
|
(b! #t cfg-42 :delay (nop!))
|
|
(label cfg-39)
|
|
(b! (not s3-0) cfg-41 :delay (empty-form))
|
|
(set! (-> arg0 blocked-by)
|
|
(the-as rigid-body-object (-> (the-as collide-shape-prim-mesh (-> s5-0 cquery num-spheres)) cshape process))
|
|
)
|
|
0
|
|
(label cfg-41)
|
|
(vector+float*! (-> arg0 position) (-> arg0 position) (-> s5-0 vec-5) 40.96)
|
|
(rigid-body-method-24 arg0)
|
|
0
|
|
(label cfg-42)
|
|
(when (< 0.0 (-> s5-0 float-1))
|
|
(rigid-body-method-14 arg0 (* (-> s5-0 float-1) (-> s5-0 dt)))
|
|
(rigid-body-method-13 arg0)
|
|
(transform-rigid-body-prims (-> this root-prim) (-> arg0 matrix))
|
|
(set! (-> s5-0 float-1) 0.0)
|
|
)
|
|
(label cfg-44)
|
|
(let ((f0-47 (* (- 1.0 (-> s5-0 float-1)) (-> s5-0 dt))))
|
|
(set! (-> arg0 time-remaining) (- (-> arg0 time-remaining) f0-47))
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 15 of type rigid-body
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Stack slot offset 632 signed mismatch
|
|
;; WARN: Stack slot offset 632 signed mismatch
|
|
;; WARN: Stack slot offset 632 signed mismatch
|
|
;; WARN: Stack slot offset 632 signed mismatch
|
|
;; WARN: Stack slot offset 632 signed mismatch
|
|
;; WARN: Stack slot offset 632 signed mismatch
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-15 ((this rigid-body) (arg0 collide-shape-moving) (arg1 float))
|
|
(local-vars
|
|
(sv-576 vector)
|
|
(sv-624 vector)
|
|
(sv-628 vector)
|
|
(sv-632 float)
|
|
(sv-704 vector)
|
|
(sv-708 vector)
|
|
(sv-712 vector)
|
|
(sv-716 vector)
|
|
)
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
(vf6 :class vf)
|
|
(vf7 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(-> this work)
|
|
(let ((s4-0 (-> this info))
|
|
(s3-0 (new 'stack-no-clear 'collide-query))
|
|
(f30-0 1.0)
|
|
(s2-0 0)
|
|
)
|
|
(set! (-> s3-0 start-pos quad) (-> this position quad))
|
|
(let ((v1-3 s3-0))
|
|
(set! (-> v1-3 radius) (-> arg0 root-prim prim-core world-sphere w))
|
|
(set! (-> v1-3 collide-with) (-> arg0 root-prim prim-core collide-with))
|
|
(set! (-> v1-3 ignore-process0) #f)
|
|
(set! (-> v1-3 ignore-process1) #f)
|
|
(set! (-> v1-3 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1))
|
|
(set! (-> v1-3 action-mask) (collide-action solid))
|
|
)
|
|
(until (>= s2-0 4)
|
|
(vector-float*! (-> s3-0 move-dist) (-> this lin-velocity) (* f30-0 arg1))
|
|
(let ((f28-0 (probe-using-line-sphere *collide-cache* s3-0)))
|
|
(b! (>= f28-0 0.0) cfg-3)
|
|
(rigid-body-method-14 this (* f30-0 arg1))
|
|
(b! #t cfg-9 :delay (nop!))
|
|
(label cfg-3)
|
|
(rigid-body-method-14 this (* f30-0 arg1 f28-0))
|
|
(set! sv-576 (new 'stack-no-clear 'vector))
|
|
(set! sv-624 (new 'stack-no-clear 'vector))
|
|
(set! sv-628 (new 'stack-no-clear 'vector))
|
|
(vector-! sv-576 (-> this position) (-> s3-0 best-other-tri intersect))
|
|
(vector-normalize! sv-576 1.0)
|
|
(set! sv-632 (vector-dot sv-576 (-> this lin-momentum)))
|
|
(when (< sv-632 0.0)
|
|
(vector-float*! sv-624 sv-576 sv-632)
|
|
(vector-! sv-628 (-> this lin-momentum) sv-624)
|
|
(vector-float*! sv-628 sv-628 (- 1.0 (-> s4-0 friction-factor)))
|
|
(vector-float*! sv-624 sv-624 (- (-> s4-0 bounce-factor)))
|
|
(vector+! (-> this lin-momentum) sv-628 sv-624)
|
|
(vector-float*! (-> this lin-velocity) (-> this lin-momentum) (-> s4-0 inv-mass))
|
|
)
|
|
(b! (>= f28-0 0.0001) cfg-7 :delay #f)
|
|
(vector+float*! (-> this position) (-> this position) sv-576 409.6)
|
|
(label cfg-7)
|
|
(set! sv-704 (new 'stack-no-clear 'vector))
|
|
(set! sv-708 (new 'stack-no-clear 'vector))
|
|
(set! sv-712 (new 'stack-no-clear 'vector))
|
|
(set! sv-716 (new 'stack-no-clear 'vector))
|
|
(vector-! sv-704 (-> s3-0 best-other-tri intersect) (-> this position))
|
|
(rigid-body-method-22 this (-> s3-0 best-other-tri intersect) sv-708)
|
|
(vector+float*! sv-708 sv-708 sv-576 (- (vector-dot sv-708 sv-576)))
|
|
(vector-float*! sv-712 sv-708 (* -1.0 (-> s4-0 mass) (-> s4-0 friction-factor)))
|
|
(vector-cross! sv-716 sv-704 sv-712)
|
|
(let ((a1-20 (-> this ang-momentum)))
|
|
(let ((v1-46 (-> this ang-momentum)))
|
|
(let ((a0-27 sv-716))
|
|
(let ((a2-6 1.0))
|
|
(.mov vf7 a2-6)
|
|
)
|
|
(.lvf vf5 (&-> a0-27 quad))
|
|
)
|
|
(.lvf vf4 (&-> v1-46 quad))
|
|
)
|
|
(.add.x.vf vf6 vf0 vf0 :mask #b1000)
|
|
(.mul.x.vf acc vf5 vf7 :mask #b111)
|
|
(.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
|
|
(.svf (&-> a1-20 quad) vf6)
|
|
)
|
|
(vector-rotate*! (-> this ang-velocity) (-> this ang-momentum) (-> this inv-i-world))
|
|
(set! f30-0 (* f30-0 (- 1.0 f28-0)))
|
|
)
|
|
(+! s2-0 1)
|
|
)
|
|
)
|
|
(label cfg-9)
|
|
0
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 18 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-18 ((this rigid-body) (arg0 vector) (arg1 vector))
|
|
(vector+! (-> this force) (-> this force) arg1)
|
|
(let ((a3-1 (new 'stack-no-clear 'vector))
|
|
(v1-1 (new 'stack-no-clear 'vector))
|
|
)
|
|
(vector-! a3-1 arg0 (-> this position))
|
|
(vector-cross! v1-1 a3-1 arg1)
|
|
(vector+! (-> this torque) (-> this torque) v1-1)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 21 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-21 ((this rigid-body) (arg0 vector) (arg1 vector) (arg2 float))
|
|
(vector+! (-> this force) (-> this force) arg1)
|
|
(let* ((t0-2 (vector-! (new 'stack-no-clear 'vector) arg0 (-> this position)))
|
|
(v1-3 (vector-cross! (new 'stack-no-clear 'vector) t0-2 arg1))
|
|
)
|
|
(let ((f0-0 (vector-length t0-2)))
|
|
(if (< arg2 f0-0)
|
|
(vector-float*! v1-3 v1-3 (/ arg2 f0-0))
|
|
)
|
|
)
|
|
(vector+! (-> this torque) (-> this torque) v1-3)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 19 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-19 ((this rigid-body) (arg0 vector) (arg1 vector))
|
|
(let ((s5-0 (new 'stack-no-clear 'vector))
|
|
(s4-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
(-> this work)
|
|
(vector-rotate*! s4-0 arg1 (-> this matrix))
|
|
(vector-rotate*! s5-0 arg0 (-> this matrix))
|
|
(vector+! s5-0 s5-0 (-> this position))
|
|
(rigid-body-method-18 this s5-0 s4-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 20 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-20 ((this rigid-body) (arg0 vector))
|
|
(vector+! (-> this force) (-> this force) arg0)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 23 of type rigid-body
|
|
(defmethod rigid-body-method-23 ((this rigid-body) (arg0 vector))
|
|
(let ((gp-0 (new 'stack-no-clear 'vector)))
|
|
(vector-rotate*! gp-0 (-> this info cm-offset-joint) (-> this matrix))
|
|
(vector-! arg0 (-> this position) gp-0)
|
|
)
|
|
arg0
|
|
)
|
|
|
|
;; definition for method 28 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod print-force-torque ((this rigid-body) (arg0 object))
|
|
(format arg0 " force ~M ~M ~M" (-> this force x) (-> this force y) (-> this force z))
|
|
(format arg0 " torque ~M ~M ~M~%" (-> this torque x) (-> this torque y) (-> this torque z))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 30 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod print-momentum ((this rigid-body) (arg0 object))
|
|
(format arg0 " lin-mom ~M ~M ~M" (-> this lin-momentum x) (-> this lin-momentum y) (-> this lin-momentum z))
|
|
(format
|
|
arg0
|
|
" ang-mom ~M ~M ~M~%"
|
|
(-> this ang-momentum x)
|
|
(-> this ang-momentum y)
|
|
(-> this ang-momentum z)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 31 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod print-velocity ((this rigid-body) (arg0 object))
|
|
(format arg0 " lin-vel ~M ~M ~M" (-> this lin-velocity x) (-> this lin-velocity y) (-> this lin-velocity z))
|
|
(format
|
|
arg0
|
|
" ang-vel ~f ~f ~f~%"
|
|
(-> this ang-velocity x)
|
|
(-> this ang-velocity y)
|
|
(-> this ang-velocity z)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 29 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod print-position-rotation ((this rigid-body) (arg0 object))
|
|
(format arg0 " position ~M ~M ~M" (-> this position x) (-> this position y) (-> this position z))
|
|
(format
|
|
arg0
|
|
" rotation ~f ~f ~f ~f~%"
|
|
(-> this rotation x)
|
|
(-> this rotation y)
|
|
(-> this rotation z)
|
|
(-> this rotation w)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 27 of type rigid-body
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod print-physics ((this rigid-body) (arg0 object))
|
|
(print-force-torque this arg0)
|
|
(print-position-rotation this arg0)
|
|
(print-momentum this arg0)
|
|
(print-velocity this arg0)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 10 of type rigid-body-control
|
|
;; WARN: Return type mismatch int vs object.
|
|
(defmethod rigid-body-control-method-10 ((this rigid-body-control) (arg0 rigid-body-object) (arg1 float) (arg2 float))
|
|
(let* ((s4-1 (max 1 (min 4 (+ (the int (* 0.9999 (/ arg1 arg2))) 1))))
|
|
(f30-0 (/ arg1 (the float s4-1)))
|
|
(s3-0 (-> this state force-callback))
|
|
)
|
|
(while (nonzero? s4-1)
|
|
(+! s4-1 -1)
|
|
(s3-0 arg0 f30-0)
|
|
(let ((v1-2 this)
|
|
(a1-2 (-> arg0 root))
|
|
(f0-4 f30-0)
|
|
)
|
|
(rigid-body-method-9 (-> v1-2 state) a1-2 f0-4)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
)
|
|
|
|
;; definition for method 11 of type rigid-body
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-method-11 ((this rigid-body) (arg0 collide-shape-moving))
|
|
(quaternion-copy! (-> arg0 quat) (-> this rotation))
|
|
(rigid-body-method-23 this (-> arg0 trans))
|
|
(set! (-> arg0 transv quad) (-> this lin-velocity quad))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 26 of type rigid-body-object
|
|
(defmethod get-inv-mass ((this rigid-body-object))
|
|
(-> this info info inv-mass)
|
|
)
|
|
|
|
;; definition for method 35 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-35 ((this rigid-body-object))
|
|
(let ((a0-1 (-> this info name)))
|
|
(when (nonzero? a0-1)
|
|
(set! (-> this info) (the-as rigid-body-object-constants (-> a0-1 value)))
|
|
(set! (-> this rbody state info) (-> this info info))
|
|
)
|
|
)
|
|
(rigid-body-info-method-9 (-> this info info))
|
|
(set! (-> this rbody state force-callback) (method-of-object this rigid-body-object-method-29))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 50 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-50 ((this rigid-body-object) (arg0 float))
|
|
(when (logtest? (-> this flags) (rigid-body-object-flag player-impulse-force player-contact-force))
|
|
(when (logtest? (-> this flags) (rigid-body-object-flag player-impulse-force))
|
|
(logclear! (-> this flags) (rigid-body-object-flag player-impulse-force))
|
|
(vector-float*! (-> this player-force) (-> this player-force) (/ 1.0 arg0))
|
|
)
|
|
(let ((v1-10 (-> this rbody))
|
|
(a1-1 (-> this player-force-position))
|
|
(a2-2 (-> this player-force))
|
|
)
|
|
(rigid-body-method-18 (-> v1-10 state) a1-1 a2-2)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 29 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-29 ((this rigid-body-object) (arg0 float))
|
|
(let ((a1-1 (new 'stack-no-clear 'vector)))
|
|
(vector-reset! a1-1)
|
|
(set! (-> a1-1 y) (* -1.0 (-> this info extra gravity) (-> this rbody state info mass)))
|
|
(rigid-body-method-20 (-> this rbody state) a1-1)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 30 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-30 ((this rigid-body-object))
|
|
(rigid-body-control-method-10 (-> this rbody) this (seconds-per-frame) (-> this max-time-step))
|
|
(logclear! (-> this flags) (rigid-body-object-flag player-impulse-force player-contact-force))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 51 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-51 ((this rigid-body-object))
|
|
(rigid-body-control-method-10
|
|
(-> this rbody)
|
|
this
|
|
(-> this rbody state time-remaining)
|
|
(-> this max-time-step)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 52 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-52 ((this rigid-body-object))
|
|
(logclear! (-> this flags) (rigid-body-object-flag player-impulse-force player-contact-force))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 34 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-34 ((this rigid-body-object))
|
|
(go (method-of-object this idle))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 31 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod alloc-and-init-rigid-body-control ((this rigid-body-object) (arg0 rigid-body-object-constants))
|
|
(set! (-> this info) arg0)
|
|
(set! (-> this rbody) (new 'process 'rigid-body-control this))
|
|
(update-transforms (-> this root))
|
|
(rigid-body-method-25
|
|
(-> this rbody state)
|
|
(-> this info info)
|
|
(-> this root trans)
|
|
(-> this root quat)
|
|
(method-of-object this rigid-body-object-method-29)
|
|
)
|
|
(rigid-body-object-method-35 this)
|
|
(set! (-> this max-time-step) (-> arg0 extra max-time-step))
|
|
(set! (-> this root max-iteration-count) (the-as uint 4))
|
|
(let ((v1-15 (-> this skel root-channel 0)))
|
|
(set! (-> v1-15 num-func) num-func-identity)
|
|
(set! (-> v1-15 frame-num) 0.0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 32 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod allocate-and-init-cshape ((this rigid-body-object))
|
|
(let ((s5-0 (new 'process 'collide-shape-moving this (collide-list-enum hit-by-player))))
|
|
(set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
|
|
(set! (-> s5-0 reaction) cshape-reaction-default)
|
|
(set! (-> s5-0 no-reaction)
|
|
(the-as (function collide-shape-moving collide-query vector vector object) nothing)
|
|
)
|
|
(let ((s4-0 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
|
|
(set! (-> s4-0 prim-core collide-as) (collide-spec pusher))
|
|
(set! (-> s4-0 prim-core collide-with) (collide-spec jak player-list))
|
|
(set! (-> s4-0 prim-core action) (collide-action solid))
|
|
(set! (-> s4-0 transform-index) 3)
|
|
(set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 12288.0)
|
|
(set! (-> s5-0 total-prims) (the-as uint 1))
|
|
(set! (-> s5-0 root-prim) s4-0)
|
|
)
|
|
(pusher-init s5-0)
|
|
(set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
|
|
(let ((v1-16 (-> s5-0 root-prim)))
|
|
(set! (-> s5-0 backup-collide-as) (-> v1-16 prim-core collide-as))
|
|
(set! (-> s5-0 backup-collide-with) (-> v1-16 prim-core collide-with))
|
|
)
|
|
(set! (-> this root) s5-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for symbol *rigid-body-object-constants*, type rigid-body-object-constants
|
|
(define *rigid-body-object-constants* (new 'static 'rigid-body-object-constants
|
|
:info (new 'static 'rigid-body-info
|
|
:mass 2.0
|
|
:inv-mass 0.5
|
|
:linear-damping 1.0
|
|
:angular-damping 1.0
|
|
:bounce-factor 0.5
|
|
:friction-factor 0.1
|
|
:cm-offset-joint (new 'static 'vector :w 1.0)
|
|
:inertial-tensor-box (new 'static 'array meters 3 (meters 4) (meters 4) (meters 4))
|
|
)
|
|
:extra (new 'static 'rigid-body-object-extra-info
|
|
:max-time-step 0.033333335
|
|
:gravity (meters 80)
|
|
:idle-distance (meters 50)
|
|
:attack-force-scale 1.0
|
|
)
|
|
:name '*rigid-body-object-constants*
|
|
)
|
|
)
|
|
|
|
;; definition for method 33 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod init-skel-and-rigid-body ((this rigid-body-object))
|
|
(alloc-and-init-rigid-body-control this *rigid-body-object-constants*)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 11 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod init-from-entity! ((this rigid-body-object) (arg0 entity-actor))
|
|
"Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
|
|
This commonly includes things such as:
|
|
- stack size
|
|
- collision information
|
|
- loading the skeleton group / bones
|
|
- sounds"
|
|
(allocate-and-init-cshape this)
|
|
(process-drawable-from-entity! this arg0)
|
|
(init-skel-and-rigid-body this)
|
|
(rigid-body-object-method-34 this)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 36 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod do-engine-sounds ((this rigid-body-object))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 37 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-37 ((this rigid-body-object))
|
|
(rigid-body-object-method-30 this)
|
|
(do-engine-sounds this)
|
|
(let ((v1-4 (-> this rbody))
|
|
(a1-0 (-> this root))
|
|
)
|
|
(rigid-body-method-11 (-> v1-4 state) a1-0)
|
|
)
|
|
(transform-post)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 40 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-40 ((this rigid-body-object))
|
|
(logior! (-> this flags) (rigid-body-object-flag enable-collision))
|
|
(let ((v1-3 (-> this root root-prim)))
|
|
(set! (-> v1-3 prim-core collide-as) (-> this root backup-collide-as))
|
|
(set! (-> v1-3 prim-core collide-with) (-> this root backup-collide-with))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 41 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-41 ((this rigid-body-object))
|
|
(logclear! (-> this flags) (rigid-body-object-flag enable-collision))
|
|
(let ((v1-3 (-> this root root-prim)))
|
|
(set! (-> v1-3 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-3 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 38 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-38 ((this rigid-body-object))
|
|
(when (not (logtest? (-> this rbody state flags) (rigid-body-flag enable-physics)))
|
|
(logior! (-> this rbody state flags) (rigid-body-flag enable-physics))
|
|
(rigid-body-method-26 (-> this rbody state) (-> this root trans) (-> this root quat))
|
|
(vector-float*! (-> this rbody state lin-momentum) (-> this root transv) (-> this info info mass))
|
|
(vector-reset! (-> this rbody state ang-momentum))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 39 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-39 ((this rigid-body-object))
|
|
(logclear! (-> this rbody state flags) (rigid-body-flag enable-physics))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 42 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-42 ((this rigid-body-object))
|
|
(logior! (-> this flags) (rigid-body-object-flag disturbed))
|
|
(set-time! (-> this disturbed-time))
|
|
(if (not (logtest? (-> this rbody state flags) (rigid-body-flag enable-physics)))
|
|
(rigid-body-object-method-38 this)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 43 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-43 ((this rigid-body-object))
|
|
(go (method-of-object this active))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 44 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod apply-damage ((this rigid-body-object) (arg0 float) (arg1 rigid-body-impact))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 45 of type rigid-body-object
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-45 ((this rigid-body-object) (arg0 rigid-body-impact))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 49 of type rigid-body-object
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod rigid-body-object-method-49 ((this rigid-body-object) (arg0 rigid-body-impact) (arg1 touching-shapes-entry))
|
|
(set! (-> arg0 rbody) #f)
|
|
(set! (-> arg0 prim-id) (the-as uint 0))
|
|
(vector-reset! (-> arg0 normal))
|
|
(vector-reset! (-> arg0 velocity))
|
|
(set! (-> arg0 point quad) (-> this root trans quad))
|
|
(when arg1
|
|
(let ((s3-0 (-> arg1 head)))
|
|
(when s3-0
|
|
(get-intersect-point (-> arg0 point) s3-0 (-> this root) arg1)
|
|
(let ((s5-1 (get-touched-prim s3-0 (-> this root) arg1)))
|
|
(when s5-1
|
|
(set! (-> arg0 prim-id) (-> s5-1 prim-id))
|
|
(vector-! (-> arg0 normal) (-> arg0 point) (the-as vector (-> s5-1 prim-core)))
|
|
(vector-normalize! (-> arg0 normal) 1.0)
|
|
(vector+float*!
|
|
(-> arg0 point)
|
|
(the-as vector (-> s5-1 prim-core))
|
|
(-> arg0 normal)
|
|
(-> s5-1 prim-core world-sphere w)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 47 of type rigid-body-object
|
|
;; INFO: Used lq/sq
|
|
(defmethod rigid-body-object-method-47 ((this rigid-body-object)
|
|
(arg0 process-drawable)
|
|
(arg1 attack-info)
|
|
(arg2 touching-shapes-entry)
|
|
(arg3 penetrate)
|
|
)
|
|
(local-vars (f0-2 float))
|
|
(when arg2
|
|
(let ((s5-0 (new 'stack-no-clear 'rigid-body-impact)))
|
|
(rigid-body-object-method-49 this s5-0 arg2)
|
|
(if (logtest? (attack-mask attacker-velocity) (-> arg1 mask))
|
|
(set! (-> s5-0 velocity quad) (-> arg1 attacker-velocity quad))
|
|
(vector-! (-> s5-0 velocity) (-> s5-0 point) (-> arg0 root trans))
|
|
)
|
|
0.0
|
|
0.0
|
|
(let ((f1-0 (cond
|
|
((logtest? (penetrate enemy-yellow-shot) arg3)
|
|
(set! f0-2 8192.0)
|
|
0.025
|
|
)
|
|
((logtest? (penetrate jak-yellow-shot jak-blue-shot) arg3)
|
|
(set! f0-2 8192.0)
|
|
0.05
|
|
)
|
|
((logtest? (penetrate jak-red-shot) arg3)
|
|
(set! f0-2 16384.0)
|
|
0.05
|
|
)
|
|
((logtest? (penetrate explode jak-dark-shot enemy-dark-shot) arg3)
|
|
(set! f0-2 81920.0)
|
|
1.5
|
|
)
|
|
((logtest? arg3 (penetrate punch))
|
|
(set! f0-2 40960.0)
|
|
0.1
|
|
)
|
|
((logtest? arg3 (penetrate flop spin))
|
|
(set! f0-2 20480.0)
|
|
0.05
|
|
)
|
|
(else
|
|
(set! f0-2 8192.0)
|
|
0.01
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> s5-0 impulse) (* f0-2 (-> this info extra attack-force-scale)))
|
|
(apply-damage this (* 0.667 f1-0) s5-0)
|
|
)
|
|
(rigid-body-object-method-42 this)
|
|
(let ((s4-1 (new 'stack-no-clear 'vector)))
|
|
(set! (-> s4-1 quad) (-> s5-0 velocity quad))
|
|
(vector-normalize! s4-1 1.0)
|
|
(vector-float*! s4-1 s4-1 (-> s5-0 impulse))
|
|
(let ((v1-46 (-> this rbody))
|
|
(a1-6 (-> s5-0 point))
|
|
(a2-3 s4-1)
|
|
)
|
|
(rigid-body-method-18 (-> v1-46 state) a1-6 a2-3)
|
|
)
|
|
(let ((v1-49 (-> this rbody))
|
|
(f0-7 1.0)
|
|
)
|
|
(rigid-body-method-12 (-> v1-49 state) f0-7)
|
|
)
|
|
(rigid-body-method-13 (-> this rbody state))
|
|
(when #t
|
|
(add-debug-x #t (bucket-id debug-no-zbuf1) (-> s5-0 point) *color-blue*)
|
|
(add-debug-vector #t (bucket-id debug-no-zbuf1) (-> s5-0 point) s4-1 (meters 0.00024414062) *color-blue*)
|
|
)
|
|
)
|
|
(rigid-body-object-method-45 this s5-0)
|
|
)
|
|
(if (and (-> this next-state) (= (-> this next-state name) 'idle))
|
|
(rigid-body-object-method-43 this)
|
|
)
|
|
#t
|
|
)
|
|
)
|
|
|
|
;; definition for method 48 of type rigid-body-object
|
|
;; INFO: Used lq/sq
|
|
(defmethod rigid-body-object-method-48 ((this rigid-body-object) (arg0 process-focusable) (arg1 touching-shapes-entry))
|
|
(local-vars (v1-2 symbol))
|
|
(b! (not (logtest? (process-mask target crate enemy) (-> arg0 mask))) cfg-5 :likely-delay (set! v1-2 #t))
|
|
(b! (not (logtest? (-> arg0 mask) (process-mask target))) cfg-5 :likely-delay (set! v1-2 #f))
|
|
(set! v1-2 (focus-test? arg0 dangerous pilot))
|
|
(label cfg-5)
|
|
(b! v1-2 cfg-17 :delay (nop!))
|
|
(let ((s5-0 (new 'stack-no-clear 'rigid-body-impact))
|
|
(s4-0 (new 'stack-no-clear 'vector))
|
|
(f30-0 (get-inv-mass arg0))
|
|
)
|
|
(rigid-body-object-method-49 this s5-0 arg1)
|
|
(cond
|
|
((logtest? (-> this rbody state flags) (rigid-body-flag enable-physics))
|
|
(let ((v1-14 (-> this rbody))
|
|
(a1-3 (-> s5-0 point))
|
|
(a2-2 (-> s5-0 velocity))
|
|
)
|
|
(rigid-body-method-22 (-> v1-14 state) a1-3 a2-2)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> s5-0 velocity quad) (-> this root transv quad))
|
|
)
|
|
)
|
|
(let ((v1-18 (-> arg0 root)))
|
|
(set! (-> s4-0 quad) (-> v1-18 transv quad))
|
|
(vector-! (-> s5-0 velocity) (-> v1-18 transv) (-> s5-0 velocity))
|
|
)
|
|
(let ((f0-1 (vector-dot (-> s5-0 velocity) (-> s5-0 normal))))
|
|
(when (< f0-1 0.0)
|
|
(set! (-> s5-0 impulse) (/ f0-1 (+ f30-0 (-> this info info inv-mass))))
|
|
(vector+float*! s4-0 s4-0 (-> s5-0 normal) (* -3.1 f30-0 (-> s5-0 impulse)))
|
|
(set! (-> s4-0 y) (fmax (* 49152.0 f30-0) (-> s4-0 y)))
|
|
(rigid-body-object-method-42 this)
|
|
(let ((a2-4 (new 'stack-no-clear 'vector)))
|
|
(vector-float*! a2-4 (-> s5-0 normal) (-> s5-0 impulse))
|
|
(let ((v1-31 (-> this rbody))
|
|
(a1-8 (-> s5-0 point))
|
|
)
|
|
(rigid-body-method-18 (-> v1-31 state) a1-8 a2-4)
|
|
)
|
|
)
|
|
(let ((v1-34 (-> this rbody))
|
|
(f0-10 1.0)
|
|
)
|
|
(rigid-body-method-12 (-> v1-34 state) f0-10)
|
|
)
|
|
(rigid-body-method-13 (-> this rbody state))
|
|
(when #f
|
|
(add-debug-x #t (bucket-id debug-no-zbuf1) (-> s5-0 point) *color-blue*)
|
|
(add-debug-vector
|
|
#t
|
|
(bucket-id debug-no-zbuf1)
|
|
(-> s5-0 point)
|
|
(-> s5-0 normal)
|
|
(- (-> s5-0 impulse))
|
|
*color-blue*
|
|
)
|
|
)
|
|
(rigid-body-object-method-45 this s5-0)
|
|
(if (and (-> this next-state) (= (-> this next-state name) 'idle))
|
|
(rigid-body-object-method-43 this)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(label cfg-17)
|
|
#t
|
|
)
|
|
|
|
;; definition for method 46 of type rigid-body-object
|
|
;; INFO: Used lq/sq
|
|
(defmethod rigid-body-object-method-46 ((this rigid-body-object) (arg0 process-drawable) (arg1 int) (arg2 symbol) (arg3 event-message-block))
|
|
(case arg2
|
|
(('impact-impulse)
|
|
(let ((s5-1 (-> arg3 param 0)))
|
|
(if (!= this arg0)
|
|
(rigid-body-object-method-42 this)
|
|
)
|
|
(rigid-body-object-method-45 this (the-as rigid-body-impact s5-1))
|
|
)
|
|
(if (and (-> this next-state) (= (-> this next-state name) 'idle))
|
|
(rigid-body-object-method-43 this)
|
|
)
|
|
)
|
|
(('touched)
|
|
(if (= this *debug-actor*)
|
|
(format *stdcon* "rigid-body-object got touched~%")
|
|
)
|
|
(when (zero? (-> arg0 rbody))
|
|
(let ((s3-0 (if (type? arg0 process-focusable)
|
|
(the-as process-focusable arg0)
|
|
)
|
|
)
|
|
)
|
|
(when s3-0
|
|
(when (logtest? (-> s3-0 mask) (process-mask target))
|
|
(logior! (-> this flags) (rigid-body-object-flag player-touching))
|
|
(set-time! (-> this player-touch-time))
|
|
(rigid-body-object-method-42 this)
|
|
)
|
|
(if (not (logtest? (-> s3-0 mask) (process-mask target)))
|
|
(rigid-body-object-method-48 this s3-0 (the-as touching-shapes-entry (-> arg3 param 0)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('attack)
|
|
(let ((s3-1 (the-as attack-info (-> arg3 param 1)))
|
|
(t0-1 (get-penetrate-using-from-attack-event arg0 arg3))
|
|
)
|
|
(when (!= (-> s3-1 id) (-> this incoming-attack-id))
|
|
(set! (-> this incoming-attack-id) (-> s3-1 id))
|
|
(rigid-body-object-method-47 this arg0 s3-1 (the-as touching-shapes-entry (-> arg3 param 0)) t0-1)
|
|
)
|
|
)
|
|
)
|
|
(('edge-grabbed 'pilot-edge-grab)
|
|
(let ((s5-2 (the-as object (-> arg3 param 0))))
|
|
(when (not (logtest? (-> this flags) (rigid-body-object-flag player-impulse-force)))
|
|
(let ((a0-25 (if (type? arg0 process-focusable)
|
|
(the-as process-focusable arg0)
|
|
)
|
|
)
|
|
)
|
|
(when a0-25
|
|
(let ((f0-1 (/ 163840.0 (get-inv-mass a0-25))))
|
|
(logior! (-> this flags) (rigid-body-object-flag player-touching player-edge-grabbing player-contact-force))
|
|
(set! (-> this player-force-position quad) (-> (the-as attack-info s5-2) attacker-velocity quad))
|
|
(vector-reset! (-> this player-force))
|
|
(set! (-> this player-force y) (* -1.0 f0-1))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(not (logtest? (-> this focus-status) (focus-status dead inactive)))
|
|
)
|
|
(('ridden)
|
|
(let ((v1-45 (the-as object (-> arg3 param 0))))
|
|
(when (the-as uint v1-45)
|
|
(let* ((s5-3 (handle->process (-> (the-as focus v1-45) handle)))
|
|
(a0-34 (if (type? s5-3 process-focusable)
|
|
(the-as process-focusable s5-3)
|
|
)
|
|
)
|
|
)
|
|
(when (and a0-34
|
|
(logtest? (-> a0-34 mask) (process-mask target))
|
|
(not (logtest? (-> a0-34 focus-status) (focus-status on-water under-water)))
|
|
)
|
|
(when (not (logtest? (-> this flags) (rigid-body-object-flag player-impulse-force)))
|
|
(logior! (-> this flags) (rigid-body-object-flag player-touching player-standing-on player-contact-force))
|
|
(set! (-> this player-force-position quad) (-> a0-34 root trans quad))
|
|
(vector-reset! (-> this player-force))
|
|
(let ((f0-4 (/ 163840.0 (get-inv-mass a0-34)))
|
|
(f1-1 1.0)
|
|
)
|
|
(set! (-> this player-force y) (* -1.0 f0-4 f1-1))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('bonk)
|
|
(when #t
|
|
(let ((a0-38 (if (type? arg0 process-focusable)
|
|
(the-as process-focusable arg0)
|
|
)
|
|
)
|
|
)
|
|
(when a0-38
|
|
(logior! (-> this flags) (rigid-body-object-flag player-touching player-impulse-force))
|
|
(set! (-> this player-force-position quad) (-> a0-38 root trans quad))
|
|
(let ((f30-2 (* 0.00012207031 (the-as float (-> arg3 param 1))))
|
|
(f0-9 (/ 163840.0 (get-inv-mass a0-38)))
|
|
)
|
|
(vector-reset! (-> this player-force))
|
|
(set! (-> this player-force y) (* -0.1 f0-9 f30-2))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('enable-physics)
|
|
(rigid-body-object-method-42 this)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function rigid-body-object-event-handler
|
|
(defbehavior rigid-body-object-event-handler rigid-body-object ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
|
|
(rigid-body-object-method-46 self (the-as process-drawable arg0) arg1 arg2 arg3)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate idle (rigid-body-object)
|
|
:virtual #t
|
|
:trans (behavior ()
|
|
(if (and *target* (and (>= (-> self info extra idle-distance)
|
|
(vector-vector-distance (-> self root trans) (-> *target* control trans))
|
|
)
|
|
(not (logtest? (focus-status teleporting) (-> *target* focus-status)))
|
|
)
|
|
)
|
|
(go-virtual active)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
:post ja-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (rigid-body-object)
|
|
:virtual #t
|
|
:event rigid-body-object-event-handler
|
|
:trans (behavior ()
|
|
(if (or (not *target*) (or (< (+ 4096.0 (-> self info extra idle-distance))
|
|
(vector-vector-distance (-> self root trans) (-> *target* control trans))
|
|
)
|
|
(focus-test? *target* teleporting)
|
|
)
|
|
)
|
|
(go-virtual idle)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
:post (behavior ()
|
|
(rigid-body-object-method-37 self)
|
|
)
|
|
)
|