mirror of
https://github.com/open-goal/jak-project
synced 2026-06-06 19:52:01 -04:00
Tyler Wilding
f6bdc07990
This PR does a few main things: - finish decompiling the progress related code - implemented changes necessary to load the text files end-to-end - japanese/korean character encodings were not added - finish more camera code, which is required to spawn the progress menu / init the default language settings needed for text - initialized the camera as well Still havn't opened the menu as there are a lot of checks around `*target*` which I havn't yet gone through and attempted to comment out.
689 lines
30 KiB
Common Lisp
Vendored
Generated
689 lines
30 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type cam-index
|
|
(deftype cam-index (structure)
|
|
((flags cam-index-options :offset-assert 0)
|
|
(vec vector 2 :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x30
|
|
:flag-assert #xb00000030
|
|
(:methods
|
|
(cam-index-method-9 (_type_ symbol entity vector curve) symbol 9)
|
|
(cam-index-method-10 (_type_ vector) float 10)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type cam-index
|
|
(defmethod inspect cam-index ((obj cam-index))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'cam-index)
|
|
(format #t "~1Tflags: ~D~%" (-> obj flags))
|
|
(format #t "~1Tvec[2] @ #x~X~%" (-> obj vec))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type tracking-point
|
|
(deftype tracking-point (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(direction vector :inline :offset-assert 16)
|
|
(tp-length float :offset-assert 32)
|
|
(next int32 :offset-assert 36)
|
|
(incarnation int32 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|
|
;; definition for method 3 of type tracking-point
|
|
(defmethod inspect tracking-point ((obj tracking-point))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'tracking-point)
|
|
(format #t "~1Tposition: #<vector @ #x~X>~%" (-> obj position))
|
|
(format #t "~1Tdirection: #<vector @ #x~X>~%" (-> obj direction))
|
|
(format #t "~1Ttp-length: ~f~%" (-> obj tp-length))
|
|
(format #t "~1Tnext: ~D~%" (-> obj next))
|
|
(format #t "~1Tincarnation: ~D~%" (-> obj incarnation))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type tracking-spline-sampler
|
|
(deftype tracking-spline-sampler (structure)
|
|
((cur-pt int32 :offset-assert 0)
|
|
(partial-pt float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|
|
;; definition for method 3 of type tracking-spline-sampler
|
|
(defmethod inspect tracking-spline-sampler ((obj tracking-spline-sampler))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'tracking-spline-sampler)
|
|
(format #t "~1Tcur-pt: ~D~%" (-> obj cur-pt))
|
|
(format #t "~1Tpartial-pt: ~f~%" (-> obj partial-pt))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type tracking-spline
|
|
(deftype tracking-spline (structure)
|
|
((point tracking-point 32 :inline :offset-assert 0)
|
|
(summed-len float :offset-assert 1536)
|
|
(free-point int32 :offset-assert 1540)
|
|
(used-point int32 :offset-assert 1544)
|
|
(partial-point float :offset-assert 1548)
|
|
(end-point int32 :offset-assert 1552)
|
|
(next-to-last-point int32 :offset-assert 1556)
|
|
(max-move float :offset-assert 1560)
|
|
(sample-len float :offset-assert 1564)
|
|
(used-count int32 :offset-assert 1568)
|
|
(old-position vector :inline :offset-assert 1584)
|
|
(debug-old-position vector :inline :offset-assert 1600)
|
|
(debug-out-position vector :inline :offset-assert 1616)
|
|
(debug-last-point int32 :offset-assert 1632)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x664
|
|
:flag-assert #x1800000664
|
|
(:methods
|
|
(tracking-spline-method-9 (_type_) none 9)
|
|
(tracking-spline-method-10 (_type_ vector) none 10)
|
|
(debug-point-info (_type_ int) none 11)
|
|
(debug-all-points (_type_) none 12)
|
|
(tracking-spline-method-13 (_type_ int) none 13)
|
|
(tracking-spline-method-14 (_type_ tracking-spline-sampler) none 14)
|
|
(tracking-spline-method-15 (_type_) none 15)
|
|
(tracking-spline-method-16 (_type_ float) none 16)
|
|
(tracking-spline-method-17 (_type_ vector float float symbol) int 17)
|
|
(tracking-spline-method-18 (_type_ float vector tracking-spline-sampler) vector 18)
|
|
(tracking-spline-method-19 (_type_ float vector tracking-spline-sampler) vector 19)
|
|
(tracking-spline-method-20 (_type_ vector int) none 20)
|
|
(tracking-spline-method-21 (_type_ vector float float float) vector 21)
|
|
(tracking-spline-method-22 (_type_ float) symbol 22)
|
|
(debug-draw-spline (_type_) none 23)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type tracking-spline
|
|
(defmethod inspect tracking-spline ((obj tracking-spline))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'tracking-spline)
|
|
(format #t "~1Tpoint[32] @ #x~X~%" (-> obj point))
|
|
(format #t "~1Tsummed-len: ~f~%" (-> obj summed-len))
|
|
(format #t "~1Tfree-point: ~D~%" (-> obj free-point))
|
|
(format #t "~1Tused-point: ~D~%" (-> obj used-point))
|
|
(format #t "~1Tpartial-point: ~f~%" (-> obj partial-point))
|
|
(format #t "~1Tend-point: ~D~%" (-> obj end-point))
|
|
(format #t "~1Tnext-to-last-point: ~D~%" (-> obj next-to-last-point))
|
|
(format #t "~1Tmax-move: ~f~%" (-> obj max-move))
|
|
(format #t "~1Tsample-len: ~f~%" (-> obj sample-len))
|
|
(format #t "~1Tused-count: ~D~%" (-> obj used-count))
|
|
(format #t "~1Told-position: #<vector @ #x~X>~%" (-> obj old-position))
|
|
(format #t "~1Tdebug-old-position: #<vector @ #x~X>~%" (-> obj debug-old-position))
|
|
(format #t "~1Tdebug-out-position: #<vector @ #x~X>~%" (-> obj debug-out-position))
|
|
(format #t "~1Tdebug-last-point: ~D~%" (-> obj debug-last-point))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type cam-float-seeker
|
|
(deftype cam-float-seeker (structure)
|
|
((target float :offset-assert 0)
|
|
(value float :offset-assert 4)
|
|
(vel float :offset-assert 8)
|
|
(accel float :offset-assert 12)
|
|
(max-vel float :offset-assert 16)
|
|
(max-partial float :offset-assert 20)
|
|
)
|
|
:pack-me
|
|
:method-count-assert 13
|
|
:size-assert #x18
|
|
:flag-assert #xd00000018
|
|
(:methods
|
|
(init (_type_ float float float float) none 9)
|
|
(copy-to (_type_ _type_) none 10)
|
|
(update! (_type_ float) none 11)
|
|
(jump-to-target! (_type_ float) float 12)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type cam-float-seeker
|
|
(defmethod inspect cam-float-seeker ((obj cam-float-seeker))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'cam-float-seeker)
|
|
(format #t "~1Ttarget: ~f~%" (-> obj target))
|
|
(format #t "~1Tvalue: ~f~%" (-> obj value))
|
|
(format #t "~1Tvel: ~f~%" (-> obj vel))
|
|
(format #t "~1Taccel: ~f~%" (-> obj accel))
|
|
(format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
|
|
(format #t "~1Tmax-partial: ~f~%" (-> obj max-partial))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 9 of type cam-float-seeker
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod init cam-float-seeker ((obj cam-float-seeker) (arg0 float) (arg1 float) (arg2 float) (arg3 float))
|
|
(set! (-> obj target) arg0)
|
|
(set! (-> obj value) arg0)
|
|
(set! (-> obj vel) 0.0)
|
|
(set! (-> obj accel) arg1)
|
|
(set! (-> obj max-vel) arg2)
|
|
(set! (-> obj max-partial) arg3)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 10 of type cam-float-seeker
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod copy-to cam-float-seeker ((obj cam-float-seeker) (arg0 cam-float-seeker))
|
|
(set! (-> obj target) (-> arg0 target))
|
|
(set! (-> obj value) (-> arg0 value))
|
|
(set! (-> obj vel) (-> arg0 vel))
|
|
(set! (-> obj accel) (-> arg0 accel))
|
|
(set! (-> obj max-vel) (-> arg0 max-vel))
|
|
(set! (-> obj max-partial) (-> arg0 max-partial))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 11 of type cam-float-seeker
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod update! cam-float-seeker ((obj cam-float-seeker) (arg0 float))
|
|
(with-pp
|
|
0.0
|
|
0.0
|
|
(let* ((f1-2 (- (+ (-> obj target) arg0) (-> obj value)))
|
|
(f0-5 (* (-> obj max-partial) (fabs f1-2)))
|
|
)
|
|
(let ((f1-3 (* f1-2 (* (-> obj accel) (-> pp clock time-adjust-ratio)))))
|
|
(+! (-> obj vel) f1-3)
|
|
)
|
|
(let ((f1-6 (fabs (-> obj vel)))
|
|
(f0-6 (fmin f0-5 (-> obj max-vel)))
|
|
)
|
|
(if (< f0-6 f1-6)
|
|
(set! (-> obj vel) (* (-> obj vel) (/ f0-6 f1-6)))
|
|
)
|
|
)
|
|
)
|
|
(let ((f0-10 (* (-> obj vel) (-> pp clock time-adjust-ratio))))
|
|
(+! (-> obj value) f0-10)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 12 of type cam-float-seeker
|
|
(defmethod jump-to-target! cam-float-seeker ((obj cam-float-seeker) (arg0 float))
|
|
(set! (-> obj value) (+ (-> obj target) arg0))
|
|
(set! (-> obj vel) 0.0)
|
|
0.0
|
|
)
|
|
|
|
;; definition of type cam-vector-seeker
|
|
(deftype cam-vector-seeker (structure)
|
|
((target vector :inline :offset-assert 0)
|
|
(value vector :inline :offset-assert 16)
|
|
(vel vector :inline :offset-assert 32)
|
|
(accel float :offset-assert 48)
|
|
(max-vel float :offset-assert 52)
|
|
(max-partial float :offset-assert 56)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x3c
|
|
:flag-assert #xb0000003c
|
|
(:methods
|
|
(init (_type_ vector float float float) none 9)
|
|
(update! (_type_ vector) none 10)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type cam-vector-seeker
|
|
(defmethod inspect cam-vector-seeker ((obj cam-vector-seeker))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'cam-vector-seeker)
|
|
(format #t "~1Ttarget: #<vector @ #x~X>~%" (-> obj target))
|
|
(format #t "~1Tvalue: #<vector @ #x~X>~%" (-> obj value))
|
|
(format #t "~1Tvel: #<vector @ #x~X>~%" (-> obj vel))
|
|
(format #t "~1Taccel: ~f~%" (-> obj accel))
|
|
(format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
|
|
(format #t "~1Tmax-partial: ~f~%" (-> obj max-partial))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 9 of type cam-vector-seeker
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod init cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector) (arg1 float) (arg2 float) (arg3 float))
|
|
(cond
|
|
(arg0
|
|
(set! (-> obj target quad) (-> arg0 quad))
|
|
(set! (-> obj value quad) (-> arg0 quad))
|
|
)
|
|
(else
|
|
(vector-reset! (-> obj target))
|
|
(vector-reset! (-> obj value))
|
|
)
|
|
)
|
|
(vector-reset! (-> obj vel))
|
|
(set! (-> obj accel) arg1)
|
|
(set! (-> obj max-vel) arg2)
|
|
(set! (-> obj max-partial) arg3)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 10 of type cam-vector-seeker
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod update! cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector))
|
|
(with-pp
|
|
(let ((v1-0 (new 'stack-no-clear 'vector)))
|
|
0.0
|
|
(cond
|
|
(arg0
|
|
(vector+! v1-0 (-> obj target) arg0)
|
|
(vector-! v1-0 v1-0 (-> obj value))
|
|
)
|
|
(else
|
|
(vector-! v1-0 (-> obj target) (-> obj value))
|
|
)
|
|
)
|
|
(let ((f0-2 (* (-> obj max-partial) (vector-length v1-0))))
|
|
(vector-float*! v1-0 v1-0 (* (-> obj accel) (-> pp clock time-adjust-ratio)))
|
|
(vector+! (-> obj vel) (-> obj vel) v1-0)
|
|
(let ((f1-3 (vector-length (-> obj vel)))
|
|
(f0-3 (fmin f0-2 (-> obj max-vel)))
|
|
)
|
|
(if (< f0-3 f1-3)
|
|
(vector-float*! (-> obj vel) (-> obj vel) (/ f0-3 f1-3))
|
|
)
|
|
)
|
|
)
|
|
(vector-float*! v1-0 (-> obj vel) (-> pp clock time-adjust-ratio))
|
|
(vector+! (-> obj value) (-> obj value) v1-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition of type cam-rotation-tracker
|
|
(deftype cam-rotation-tracker (structure)
|
|
((inv-mat matrix :inline :offset-assert 0)
|
|
(no-follow basic :offset-assert 64)
|
|
(follow-pt vector :inline :offset-assert 80)
|
|
(follow-off vector :inline :offset-assert 96)
|
|
(follow-blend float :offset-assert 112)
|
|
(tilt-adjust cam-float-seeker :inline :offset-assert 116)
|
|
(point-of-interest-blend cam-float-seeker :inline :offset-assert 140)
|
|
(underwater-blend cam-float-seeker :inline :offset-assert 164)
|
|
(looking-at vector :inline :offset-assert 192)
|
|
(looking-interesting vector :inline :offset-assert 208)
|
|
(old-cam-trans vector :inline :offset-assert 224)
|
|
(follow-height-extra cam-float-seeker :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x108
|
|
:flag-assert #x900000108
|
|
)
|
|
|
|
;; definition for method 3 of type cam-rotation-tracker
|
|
(defmethod inspect cam-rotation-tracker ((obj cam-rotation-tracker))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'cam-rotation-tracker)
|
|
(format #t "~1Tinv-mat: ~`matrix`P~%" (-> obj inv-mat))
|
|
(format #t "~1Tno-follow: ~A~%" (-> obj no-follow))
|
|
(format #t "~1Tfollow-pt: ~`vector`P~%" (-> obj follow-pt))
|
|
(format #t "~1Tfollow-off: ~`vector`P~%" (-> obj follow-off))
|
|
(format #t "~1Tfollow-blend: ~f~%" (-> obj follow-blend))
|
|
(format #t "~1Ttilt-adjust: #<cam-float-seeker @ #x~X>~%" (-> obj tilt-adjust))
|
|
(format #t "~1Tpoint-of-interest-blend: #<cam-float-seeker @ #x~X>~%" (-> obj point-of-interest-blend))
|
|
(format #t "~1Tunderwater-blend: #<cam-float-seeker @ #x~X>~%" (-> obj underwater-blend))
|
|
(format #t "~1Tlooking-at: ~`vector`P~%" (-> obj looking-at))
|
|
(format #t "~1Tlooking-interesting: ~`vector`P~%" (-> obj looking-interesting))
|
|
(format #t "~1Told-cam-trans: ~`vector`P~%" (-> obj old-cam-trans))
|
|
(format #t "~1Tfollow-height-extra: #<cam-float-seeker @ #x~X>~%" (-> obj follow-height-extra))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type camera-combiner
|
|
(deftype camera-combiner (process)
|
|
((trans vector :inline :offset-assert 128)
|
|
(inv-camera-rot matrix :inline :offset-assert 144)
|
|
(fov float :offset-assert 208)
|
|
(interp-val float :offset-assert 212)
|
|
(interp-step float :offset-assert 216)
|
|
(dist-from-src float :offset-assert 220)
|
|
(dist-from-dest float :offset-assert 224)
|
|
(flip-control-axis vector :inline :offset-assert 240)
|
|
(velocity vector :inline :offset-assert 256)
|
|
(tracking-status uint64 :offset-assert 272)
|
|
(tracking-options int32 :offset-assert 280)
|
|
(tracking cam-rotation-tracker :inline :offset-assert 288)
|
|
(fast-rot basic :offset-assert 552)
|
|
)
|
|
:heap-base #x1b0
|
|
:method-count-assert 14
|
|
:size-assert #x22c
|
|
:flag-assert #xe01b0022c
|
|
)
|
|
|
|
;; definition for method 3 of type camera-combiner
|
|
(defmethod inspect camera-combiner ((obj camera-combiner))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~2Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(format #t "~2Tinv-camera-rot: ~`matrix`P~%" (-> obj inv-camera-rot))
|
|
(format #t "~2Tfov: ~f~%" (-> obj fov))
|
|
(format #t "~2Tinterp-val: ~f~%" (-> obj interp-val))
|
|
(format #t "~2Tinterp-step: ~f~%" (-> obj interp-step))
|
|
(format #t "~2Tdist-from-src: ~f~%" (-> obj dist-from-src))
|
|
(format #t "~2Tdist-from-dest: ~f~%" (-> obj dist-from-dest))
|
|
(format #t "~2Tflip-control-axis: #<vector @ #x~X>~%" (-> obj flip-control-axis))
|
|
(format #t "~2Tvelocity: #<vector @ #x~X>~%" (-> obj velocity))
|
|
(format #t "~2Ttracking-status: ~D~%" (-> obj tracking-status))
|
|
(format #t "~2Ttracking-options: ~D~%" (-> obj tracking-options))
|
|
(format #t "~2Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
|
|
(format #t "~2Tfast-rot: ~A~%" (-> obj fast-rot))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type camera-slave
|
|
(deftype camera-slave (process)
|
|
((trans vector :inline :offset-assert 128)
|
|
(fov float :offset-assert 144)
|
|
(fov0 float :offset-assert 148)
|
|
(fov1 float :offset-assert 152)
|
|
(fov-index cam-index :inline :offset-assert 160)
|
|
(tracking cam-rotation-tracker :inline :offset-assert 208)
|
|
(view-off-param float :offset-assert 472)
|
|
(view-off vector :inline :offset-assert 480)
|
|
(joystick-saved-view-off vector :inline :offset-assert 496)
|
|
(min-z-override float :offset-assert 512)
|
|
(view-flat vector :inline :offset-assert 528)
|
|
(string-vel-dir uint32 :offset-assert 544)
|
|
(string-trans vector :inline :offset-assert 560)
|
|
(position-spline tracking-spline :inline :offset-assert 576)
|
|
(pivot-pt vector :inline :offset-assert 2224)
|
|
(pivot-rad float :offset-assert 2240)
|
|
(circular-follow vector :inline :offset-assert 2256)
|
|
(max-angle-offset float :offset-assert 2272)
|
|
(max-angle-curr float :offset-assert 2276)
|
|
(options uint32 :offset-assert 2280)
|
|
(cam-entity entity :offset-assert 2284)
|
|
(butt-timer uint64 :offset-assert 2288)
|
|
(butt-seek basic :offset-assert 2296)
|
|
(butt-vector vector :inline :offset-assert 2304)
|
|
(velocity vector :inline :offset-assert 2320)
|
|
(desired-pos vector :inline :offset-assert 2336)
|
|
(time-dist-too-far uint32 :offset-assert 2352)
|
|
(los-state slave-los-state :offset-assert 2356)
|
|
(good-point vector :inline :offset-assert 2368)
|
|
(los-tgt-spline-pt int32 :offset-assert 2384)
|
|
(los-tgt-spline-pt-incarnation int32 :offset-assert 2388)
|
|
(los-last-pos vector :inline :offset-assert 2400)
|
|
(intro-curve curve :inline :offset-assert 2416)
|
|
(intro-offset vector :inline :offset-assert 2448)
|
|
(intro-t float :offset-assert 2464)
|
|
(intro-t-step float :offset-assert 2468)
|
|
(outro-exit-value float :offset-assert 2472)
|
|
(spline-exists basic :offset-assert 2476)
|
|
(spline-curve curve :inline :offset-assert 2480)
|
|
(spline-offset vector :inline :offset-assert 2512)
|
|
(index cam-index :inline :offset-assert 2528)
|
|
(saved-pt vector :inline :offset-assert 2576)
|
|
(spline-tt float :offset-assert 2592)
|
|
(spline-follow-dist float :offset-assert 2596)
|
|
(enter-has-run symbol :offset-assert 2600)
|
|
(blend-from-type uint64 :offset-assert 2608)
|
|
(blend-to-type camera-blend-to-type :offset-assert 2616)
|
|
(have-phony-joystick basic :offset-assert 2624)
|
|
(phony-joystick-x float :offset-assert 2628)
|
|
(phony-joystick-y float :offset-assert 2632)
|
|
(string-min-val vector :inline :offset-assert 2640)
|
|
(string-max-val vector :inline :offset-assert 2656)
|
|
(string-val-locked basic :offset-assert 2672)
|
|
(relative-position vector :inline :offset-assert 2688)
|
|
(string-relative basic :offset-assert 2704)
|
|
)
|
|
:heap-base #xa20
|
|
:method-count-assert 14
|
|
:size-assert #xa94
|
|
:flag-assert #xe0a200a94
|
|
(:states
|
|
cam-bike
|
|
cam-circular
|
|
cam-decel
|
|
cam-endlessfall
|
|
cam-eye
|
|
cam-fixed
|
|
cam-fixed-read-entity
|
|
cam-free-floating
|
|
cam-lookat
|
|
cam-point-watch
|
|
cam-pov
|
|
cam-pov-track
|
|
cam-pov180
|
|
cam-really-fixed
|
|
cam-robotboss
|
|
cam-spline
|
|
cam-standoff
|
|
cam-standoff-read-entity
|
|
cam-stick
|
|
cam-string
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type camera-slave
|
|
(defmethod inspect camera-slave ((obj camera-slave))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~2Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(format #t "~2Tfov: ~f~%" (-> obj fov))
|
|
(format #t "~2Tfov0: ~f~%" (-> obj fov0))
|
|
(format #t "~2Tfov1: ~f~%" (-> obj fov1))
|
|
(format #t "~2Tfov-index: #<cam-index @ #x~X>~%" (-> obj fov-index))
|
|
(format #t "~2Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
|
|
(format #t "~2Tview-off-param: ~f~%" (-> obj view-off-param))
|
|
(format #t "~2Tview-off: ~`vector`P~%" (-> obj view-off))
|
|
(format #t "~2Tjoystick-saved-view-off: ~`vector`P~%" (-> obj joystick-saved-view-off))
|
|
(format #t "~2Tmin-z-override: ~f~%" (-> obj min-z-override))
|
|
(format #t "~2Tview-flat: ~`vector`P~%" (-> obj view-flat))
|
|
(format #t "~2Tstring-vel-dir: ~D~%" (-> obj string-vel-dir))
|
|
(format #t "~2Tstring-trans: ~`vector`P~%" (-> obj string-trans))
|
|
(format #t "~2Tposition-spline: #<tracking-spline @ #x~X>~%" (-> obj position-spline))
|
|
(format #t "~2Tpivot-pt: ~`vector`P~%" (-> obj pivot-pt))
|
|
(format #t "~2Tpivot-rad: ~f~%" (-> obj pivot-rad))
|
|
(format #t "~2Tcircular-follow: #<vector @ #x~X>~%" (-> obj circular-follow))
|
|
(format #t "~2Tmax-angle-offset: ~f~%" (-> obj max-angle-offset))
|
|
(format #t "~2Tmax-angle-curr: ~f~%" (-> obj max-angle-curr))
|
|
(format #t "~2Toptions: ~D~%" (-> obj options))
|
|
(format #t "~2Tcam-entity: ~A~%" (-> obj cam-entity))
|
|
(format #t "~2Tbutt-timer: ~D~%" (-> obj butt-timer))
|
|
(format #t "~2Tbutt-seek: ~A~%" (-> obj butt-seek))
|
|
(format #t "~2Tbutt-vector: ~`vector`P~%" (-> obj butt-vector))
|
|
(format #t "~2Tvelocity: ~`vector`P~%" (-> obj velocity))
|
|
(format #t "~2Tdesired-pos: ~`vector`P~%" (-> obj desired-pos))
|
|
(format #t "~2Ttime-dist-too-far: ~D~%" (-> obj time-dist-too-far))
|
|
(format #t "~2Tlos-state: ~D~%" (-> obj los-state))
|
|
(format #t "~2Tgood-point: ~`vector`P~%" (-> obj good-point))
|
|
(format #t "~2Tlos-tgt-spline-pt: ~D~%" (-> obj los-tgt-spline-pt))
|
|
(format #t "~2Tlos-tgt-spline-pt-incarnation: ~D~%" (-> obj los-tgt-spline-pt-incarnation))
|
|
(format #t "~2Tlos-last-pos: ~`vector`P~%" (-> obj los-last-pos))
|
|
(format #t "~2Tintro-curve: #<curve @ #x~X>~%" (-> obj intro-curve))
|
|
(format #t "~2Tintro-offset: #<vector @ #x~X>~%" (-> obj intro-offset))
|
|
(format #t "~2Tintro-t: ~f~%" (-> obj intro-t))
|
|
(format #t "~2Tintro-t-step: ~f~%" (-> obj intro-t-step))
|
|
(format #t "~2Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
|
|
(format #t "~2Tspline-exists: ~A~%" (-> obj spline-exists))
|
|
(format #t "~2Tspline-curve: #<curve @ #x~X>~%" (-> obj spline-curve))
|
|
(format #t "~2Tspline-offset: #<vector @ #x~X>~%" (-> obj spline-offset))
|
|
(format #t "~2Tindex: #<cam-index @ #x~X>~%" (-> obj index))
|
|
(format #t "~2Tsaved-pt: #<vector @ #x~X>~%" (-> obj saved-pt))
|
|
(format #t "~2Tspline-tt: ~f~%" (-> obj spline-tt))
|
|
(format #t "~2Tspline-follow-dist: ~f~%" (-> obj spline-follow-dist))
|
|
(format #t "~2Tenter-has-run: ~A~%" (-> obj enter-has-run))
|
|
(format #t "~2Tblend-from-type: ~D~%" (-> obj blend-from-type))
|
|
(format #t "~2Tblend-to-type: ~D~%" (-> obj blend-to-type))
|
|
(format #t "~2Thave-phony-joystick: ~A~%" (-> obj have-phony-joystick))
|
|
(format #t "~2Tphony-joystick-x: ~f~%" (-> obj phony-joystick-x))
|
|
(format #t "~2Tphony-joystick-y: ~f~%" (-> obj phony-joystick-y))
|
|
(format #t "~2Tstring-min-val: #<vector @ #x~X>~%" (-> obj string-min-val))
|
|
(format #t "~2Tstring-max-val: #<vector @ #x~X>~%" (-> obj string-max-val))
|
|
(format #t "~2Tstring-val-locked: ~A~%" (-> obj string-val-locked))
|
|
(format #t "~2Trelative-position: #<vector @ #x~X>~%" (-> obj relative-position))
|
|
(format #t "~2Tstring-relative: ~A~%" (-> obj string-relative))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type camera-master
|
|
(deftype camera-master (process)
|
|
((master-options uint32 :offset-assert 128)
|
|
(settings cam-setting-data :offset-assert 132)
|
|
(slave (pointer camera-slave) :offset-assert 136)
|
|
(decel (pointer camera-slave) :offset-assert 140)
|
|
(slave-options uint32 :offset-assert 144)
|
|
(view-off-param-save float :offset-assert 148)
|
|
(changer uint32 :offset-assert 152)
|
|
(string-min cam-vector-seeker :inline :offset-assert 160)
|
|
(string-max cam-vector-seeker :inline :offset-assert 224)
|
|
(string-push-z float :offset-assert 284)
|
|
(local-down vector :inline :offset-assert 288)
|
|
(focus focus :inline :offset-assert 304)
|
|
(being-attacked symbol :offset-assert 316)
|
|
(attack-start time-frame :offset-assert 320)
|
|
(on-ground symbol :offset-assert 328)
|
|
(under-water int32 :offset-assert 332)
|
|
(on-pole symbol :offset-assert 336)
|
|
(tgt-rot-mat matrix :inline :offset-assert 352)
|
|
(tgt-face-mat matrix :inline :offset-assert 416)
|
|
(tpos-old vector :inline :offset-assert 480)
|
|
(tpos-curr vector :inline :offset-assert 496)
|
|
(tpos-old-adj vector :inline :offset-assert 512)
|
|
(tpos-curr-adj vector :inline :offset-assert 528)
|
|
(tpos-tgt vector :inline :offset-assert 544)
|
|
(upspeed float :offset-assert 560)
|
|
(pitch-off vector :inline :offset-assert 576)
|
|
(target-spline tracking-spline :inline :offset-assert 592)
|
|
(ease-from vector :inline :offset-assert 2240)
|
|
(ease-t float :offset-assert 2256)
|
|
(ease-step float :offset-assert 2260)
|
|
(ease-to vector :inline :offset-assert 2272)
|
|
(outro-curve curve :inline :offset-assert 2288)
|
|
(outro-t float :offset-assert 2308)
|
|
(outro-t-step float :offset-assert 2312)
|
|
(outro-exit-value float :offset-assert 2316)
|
|
(water-drip-time time-frame :offset-assert 2320)
|
|
(water-drip sparticle-launch-control :offset-assert 2328)
|
|
(water-drip-mult float :offset-assert 2332)
|
|
(water-drip-speed float :offset-assert 2336)
|
|
)
|
|
:heap-base #x8b0
|
|
:method-count-assert 17
|
|
:size-assert #x924
|
|
:flag-assert #x1108b00924
|
|
(:methods
|
|
(camera-master-method-14 (_type_ vector) vector 14)
|
|
(camera-master-method-15 (_type_ vector) vector 15)
|
|
(camera-master-method-16 (_type_ symbol) int 16)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type camera-master
|
|
(defmethod inspect camera-master ((obj camera-master))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~2Tmaster-options: ~D~%" (-> obj master-options))
|
|
(format #t "~2Tsettings: #<cam-setting-data @ #x~X>~%" (-> obj settings))
|
|
(format #t "~2Tslave: #x~X~%" (-> obj slave))
|
|
(format #t "~2Tdecel: #x~X~%" (-> obj decel))
|
|
(format #t "~2Tslave-options: ~D~%" (-> obj slave-options))
|
|
(format #t "~2Tview-off-param-save: ~f~%" (-> obj view-off-param-save))
|
|
(format #t "~2Tchanger: #x~X~%" (-> obj changer))
|
|
(format #t "~2Tstring-min: #<cam-vector-seeker @ #x~X>~%" (-> obj string-min))
|
|
(format #t "~2Tstring-max: #<cam-vector-seeker @ #x~X>~%" (-> obj string-max))
|
|
(format #t "~2Tstring-push-z: ~f~%" (-> obj string-push-z))
|
|
(format #t "~2Tlocal-down: ~`vector`P~%" (-> obj local-down))
|
|
(format #t "~2Tfocus: #<focus @ #x~X>~%" (-> obj focus))
|
|
(format #t "~2Tbeing-attacked: ~A~%" (-> obj being-attacked))
|
|
(format #t "~2Tattack-start: ~D~%" (-> obj attack-start))
|
|
(format #t "~2Ton-ground: ~A~%" (-> obj on-ground))
|
|
(format #t "~2Tunder-water: ~D~%" (-> obj under-water))
|
|
(format #t "~2Ton-pole: ~A~%" (-> obj on-pole))
|
|
(format #t "~2Ttgt-rot-mat: ~`matrix`P~%" (-> obj tgt-rot-mat))
|
|
(format #t "~2Ttgt-face-mat: ~`matrix`P~%" (-> obj tgt-face-mat))
|
|
(format #t "~2Ttpos-old: ~`vector`P~%" (-> obj tpos-old))
|
|
(format #t "~2Ttpos-curr: ~`vector`P~%" (-> obj tpos-curr))
|
|
(format #t "~2Ttpos-old-adj: ~`vector`P~%" (-> obj tpos-old-adj))
|
|
(format #t "~2Ttpos-curr-adj: ~`vector`P~%" (-> obj tpos-curr-adj))
|
|
(format #t "~2Ttpos-tgt: ~`vector`P~%" (-> obj tpos-tgt))
|
|
(format #t "~2Tupspeed: ~f~%" (-> obj upspeed))
|
|
(format #t "~2Tpitch-off: ~`vector`P~%" (-> obj pitch-off))
|
|
(format #t "~2Ttarget-spline: #<tracking-spline @ #x~X>~%" (-> obj target-spline))
|
|
(format #t "~2Tease-from: #<vector @ #x~X>~%" (-> obj ease-from))
|
|
(format #t "~2Tease-t: ~f~%" (-> obj ease-t))
|
|
(format #t "~2Tease-step: ~f~%" (-> obj ease-step))
|
|
(format #t "~2Tease-to: #<vector @ #x~X>~%" (-> obj ease-to))
|
|
(format #t "~2Toutro-curve: #<curve @ #x~X>~%" (-> obj outro-curve))
|
|
(format #t "~2Toutro-t: ~f~%" (-> obj outro-t))
|
|
(format #t "~2Toutro-t-step: ~f~%" (-> obj outro-t-step))
|
|
(format #t "~2Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
|
|
(format #t "~2Twater-drip-time: ~D~%" (-> obj water-drip-time))
|
|
(format #t "~2Twater-drip: ~A~%" (-> obj water-drip))
|
|
(format #t "~2Twater-drip-mult: ~f~%" (-> obj water-drip-mult))
|
|
(format #t "~2Twater-drip-speed: ~f~%" (-> obj water-drip-speed))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
0
|