3841 lines
138 KiB
Common Lisp
3841 lines
138 KiB
Common Lisp
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; this file is debug only
|
|
(declare-file (debug))
|
|
(when *debug-segment*
|
|
;; definition for symbol *camera-layout-blink*, type symbol
|
|
(define *camera-layout-blink* #f)
|
|
|
|
;; definition of type cam-layout-bank
|
|
(deftype cam-layout-bank (basic)
|
|
((spline-t float :offset-assert 4)
|
|
(spline-step float :offset-assert 8)
|
|
(intro-t float :offset-assert 12)
|
|
(intro-step float :offset-assert 16)
|
|
(debug-t float :offset-assert 20)
|
|
(debug-step float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|
|
;; definition for method 3 of type cam-layout-bank
|
|
(defmethod inspect cam-layout-bank ((obj cam-layout-bank))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tspline-t: ~f~%" (-> obj spline-t))
|
|
(format #t "~Tspline-step: ~f~%" (-> obj spline-step))
|
|
(format #t "~Tintro-t: ~f~%" (-> obj intro-t))
|
|
(format #t "~Tintro-step: ~f~%" (-> obj intro-step))
|
|
(format #t "~Tdebug-t: ~f~%" (-> obj debug-t))
|
|
(format #t "~Tdebug-step: ~f~%" (-> obj debug-step))
|
|
obj
|
|
)
|
|
|
|
;; definition for symbol *CAM_LAYOUT-bank*, type cam-layout-bank
|
|
(define *CAM_LAYOUT-bank* (new 'static 'cam-layout-bank
|
|
:spline-t 0.01
|
|
:spline-step 0.0016666667
|
|
:intro-t 0.01
|
|
:intro-step 0.0016666667
|
|
:debug-t 0.01
|
|
:debug-step 0.0033333334
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *camera-layout-message-ypos*, type int
|
|
(define *camera-layout-message-ypos* 30)
|
|
|
|
;; definition of type clm-basic
|
|
(deftype clm-basic (basic)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|
|
;; definition for method 3 of type clm-basic
|
|
(defmethod inspect clm-basic ((obj clm-basic))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
obj
|
|
)
|
|
|
|
;; definition of type clm-item-action
|
|
(deftype clm-item-action (structure)
|
|
((button uint64 :offset-assert 0)
|
|
(options uint64 :offset-assert 8)
|
|
(func symbol :offset-assert 16)
|
|
(parm0 int32 :offset 20)
|
|
(parm0-basic basic :offset 20)
|
|
(parm1-basic basic :offset 24)
|
|
(parm1 symbol :offset 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|
|
;; definition for method 3 of type clm-item-action
|
|
(defmethod inspect clm-item-action ((obj clm-item-action))
|
|
(format #t "[~8x] ~A~%" obj 'clm-item-action)
|
|
(format #t "~Tbutton: ~D~%" (-> obj button))
|
|
(format #t "~Toptions: ~D~%" (-> obj options))
|
|
(format #t "~Tfunc: ~A~%" (-> obj func))
|
|
(format #t "~Tparm0: ~A~%" (-> obj parm0))
|
|
(format #t "~Tparm1: ~A~%" (-> obj parm1-basic))
|
|
obj
|
|
)
|
|
|
|
;; definition of type clm-item
|
|
(deftype clm-item (clm-basic)
|
|
((description string :offset-assert 4)
|
|
(button-symbol symbol :offset-assert 8)
|
|
(action clm-item-action :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|
|
;; definition for method 3 of type clm-item
|
|
(defmethod inspect clm-item ((obj clm-item))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tdescription: ~A~%" (-> obj description))
|
|
(format #t "~Tbutton-symbol: ~A~%" (-> obj button-symbol))
|
|
(format #t "~Taction: #<clm-item-action @ #x~X>~%" (-> obj action))
|
|
obj
|
|
)
|
|
|
|
;; definition of type clm-list-item
|
|
(deftype clm-list-item (basic)
|
|
((description string :offset-assert 4)
|
|
(track-val symbol :offset-assert 8)
|
|
(val-func symbol :offset-assert 12)
|
|
(val-parm0 int32 :offset 16)
|
|
(val-parm0-basic basic :offset 16)
|
|
(val-parm1-basic basic :offset 20)
|
|
(val-parm1 symbol :offset 20)
|
|
(actions (array clm-item-action) :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|
|
;; definition for method 3 of type clm-list-item
|
|
(defmethod inspect clm-list-item ((obj clm-list-item))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tdescription: ~A~%" (-> obj description))
|
|
(format #t "~Ttrack-val: ~A~%" (-> obj track-val))
|
|
(format #t "~Tval-func: ~A~%" (-> obj val-func))
|
|
(format #t "~Tval-parm0: ~A~%" (-> obj val-parm0))
|
|
(format #t "~Tval-parm1: ~A~%" (-> obj val-parm1-basic))
|
|
(format #t "~Tactions: ~A~%" (-> obj actions))
|
|
obj
|
|
)
|
|
|
|
;; definition of type clm-list
|
|
(deftype clm-list (clm-basic)
|
|
((tracker symbol :offset-assert 4)
|
|
(cur-list-item int32 :offset-assert 8)
|
|
(items (array clm-list-item) :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|
|
;; definition for method 3 of type clm-list
|
|
(defmethod inspect clm-list ((obj clm-list))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Ttracker: ~A~%" (-> obj tracker))
|
|
(format #t "~Tcur-list-item: ~D~%" (-> obj cur-list-item))
|
|
(format #t "~Titems: ~A~%" (-> obj items))
|
|
obj
|
|
)
|
|
|
|
;; definition of type clm
|
|
(deftype clm (basic)
|
|
((title string :offset-assert 4)
|
|
(items (array clm-basic) :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|
|
;; definition for method 3 of type clm
|
|
(defmethod inspect clm ((obj clm))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Ttitle: ~A~%" (-> obj title))
|
|
(format #t "~Titems: ~A~%" (-> obj items))
|
|
obj
|
|
)
|
|
|
|
;; definition for symbol *volume-point-current*, type int
|
|
(define *volume-point-current* 0)
|
|
|
|
;; definition for symbol *volume-point*, type vector-array
|
|
(define *volume-point* (new 'debug 'vector-array 1000))
|
|
|
|
;; definition for symbol *volume-normal-current*, type int
|
|
(define *volume-normal-current* 0)
|
|
|
|
;; definition for symbol *volume-normal*, type vector-array
|
|
(define *volume-normal* (new 'debug 'vector-array 600))
|
|
|
|
;; definition of type volume-descriptor-array
|
|
(deftype volume-descriptor-array (inline-array-class)
|
|
((data plane-volume :inline :dynamic :offset 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|
|
;; definition for method 3 of type volume-descriptor-array
|
|
(defmethod inspect volume-descriptor-array ((obj volume-descriptor-array))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tlength: ~D~%" (-> obj length))
|
|
(format #t "~Tallocated-length: ~D~%" (-> obj allocated-length))
|
|
(format #t "~Tdata[0] @ #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> volume-descriptor-array heap-base) (the-as uint 24))
|
|
|
|
;; definition for symbol *volume-descriptor-current*, type int
|
|
(define *volume-descriptor-current* 0)
|
|
|
|
;; definition for symbol *volume-descriptor*, type vol-control
|
|
(define *volume-descriptor* (the-as vol-control (new 'debug 'volume-descriptor-array 100)))
|
|
|
|
;; definition of type cam-layout
|
|
(deftype cam-layout (process)
|
|
((cam-entity entity-camera :offset-assert 112)
|
|
(num-entities int32 :offset-assert 116)
|
|
(cur-entity int32 :offset-assert 120)
|
|
(num-volumes int32 :offset-assert 124)
|
|
(cur-volume int32 :offset-assert 128)
|
|
(first-pvol int32 :offset-assert 132)
|
|
(first-cutoutvol int32 :offset-assert 136)
|
|
(res-key float :offset-assert 140)
|
|
)
|
|
:heap-base #x200
|
|
:method-count-assert 14
|
|
:size-assert #x90
|
|
:flag-assert #xe02000090
|
|
(:states
|
|
cam-layout-active
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type cam-layout
|
|
(defmethod inspect cam-layout ((obj cam-layout))
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~T~Tcam-entity: ~A~%" (-> obj cam-entity))
|
|
(format #t "~T~Tnum-entities: ~D~%" (-> obj num-entities))
|
|
(format #t "~T~Tcur-entity: ~D~%" (-> obj cur-entity))
|
|
(format #t "~T~Tnum-volumes: ~D~%" (-> obj num-volumes))
|
|
(format #t "~T~Tcur-volume: ~D~%" (-> obj cur-volume))
|
|
(format #t "~T~Tfirst-pvol: ~D~%" (-> obj first-pvol))
|
|
(format #t "~T~Tfirst-cutoutvol: ~D~%" (-> obj first-cutoutvol))
|
|
(format #t "~T~Tres-key: ~f~%" (-> obj res-key))
|
|
obj
|
|
)
|
|
|
|
;; definition for function cam-layout-print
|
|
(defun cam-layout-print ((arg0 int) (arg1 int) (arg2 string))
|
|
(let* ((s5-0 (-> *display* frames (-> *display* on-screen) frame debug-buf))
|
|
(gp-0 (-> s5-0 base))
|
|
)
|
|
(draw-string-xy arg2 s5-0 arg0 arg1 (font-color white) (font-flags shadow kerning))
|
|
(let ((a3-4 (-> s5-0 base)))
|
|
(let ((v1-4 (the-as object (-> s5-0 base))))
|
|
(set! (-> (the-as dma-packet v1-4) dma) (new 'static 'dma-tag :id (dma-tag-id next)))
|
|
(set! (-> (the-as dma-packet v1-4) vif0) (new 'static 'vif-tag))
|
|
(set! (-> (the-as dma-packet v1-4) vif1) (new 'static 'vif-tag))
|
|
(set! (-> s5-0 base) (&+ (the-as pointer v1-4) 16))
|
|
)
|
|
(dma-bucket-insert-tag
|
|
(-> *display* frames (-> *display* on-screen) frame bucket-group)
|
|
(bucket-id debug)
|
|
gp-0
|
|
(the-as (pointer dma-tag) a3-4)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-intersect-dist
|
|
;; INFO: Return type mismatch number vs float.
|
|
(defun cam-layout-intersect-dist ((arg0 vector) (arg1 vector) (arg2 vector))
|
|
(let ((f0-1 (vector-dot arg1 arg0))
|
|
(f1-1 (vector-dot arg2 arg0))
|
|
)
|
|
(the-as float (if (< 0.00001 (fabs f1-1))
|
|
(/ (- (-> arg0 w) f0-1) f1-1)
|
|
409600000.0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-entity-volume-info-create
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; WARN: Stack slot offset 164 signed mismatch
|
|
;; Used lq/sq
|
|
(defbehavior cam-layout-entity-volume-info-create cam-layout ((arg0 entity-camera) (arg1 symbol))
|
|
(local-vars
|
|
(sv-16 res-tag)
|
|
(sv-160 vector)
|
|
(sv-164 float)
|
|
(sv-168 int)
|
|
(sv-176 vector)
|
|
(sv-192 vector)
|
|
(sv-208 vector)
|
|
(sv-224 vector)
|
|
(sv-240 vector)
|
|
(sv-256 int)
|
|
(sv-272 int)
|
|
(sv-288 int)
|
|
)
|
|
(let ((s4-0 0))
|
|
(loop
|
|
(set! sv-16 (new 'static 'res-tag))
|
|
(let ((s3-0 (the-as (inline-array vector) ((method-of-type res-lump get-property-data)
|
|
arg0
|
|
arg1
|
|
'exact
|
|
(the float s4-0)
|
|
(the-as pointer #f)
|
|
(& sv-16)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
(s3-0
|
|
(when (>= *volume-descriptor-current* 100)
|
|
(format 0 "ERROR <GMJ>: camera editing out of volume descriptors~%")
|
|
(return #f)
|
|
)
|
|
(let ((s2-0 (-> *volume-descriptor* pos-vol *volume-descriptor-current*)))
|
|
(set! (-> s2-0 volume-type) arg1)
|
|
(set! (-> s2-0 point-count) 0)
|
|
(set! (-> s2-0 first-point) (the-as (pointer vector) (-> *volume-point* data *volume-point-current*)))
|
|
(set! (-> s2-0 normal-count) 0)
|
|
(set! (-> s2-0 first-normal) (the-as (pointer vector) (-> *volume-normal* data *volume-normal-current*)))
|
|
(set! *volume-descriptor-current* (+ *volume-descriptor-current* 1))
|
|
(+! (-> self num-volumes) 1)
|
|
(dotimes (s1-0 (the-as int (-> sv-16 elt-count)))
|
|
(set! sv-192 (new 'stack-no-clear 'vector))
|
|
(set! (-> sv-192 quad) (the-as uint128 0))
|
|
(set! sv-208 (new 'stack-no-clear 'vector))
|
|
(set! (-> sv-208 quad) (the-as uint128 0))
|
|
(set! sv-224 (new 'stack-no-clear 'vector))
|
|
(set! (-> sv-224 quad) (the-as uint128 0))
|
|
(set! sv-240 (new 'stack-no-clear 'vector))
|
|
(set! (-> sv-240 quad) (the-as uint128 0))
|
|
0.0
|
|
0.0
|
|
0.0
|
|
(set! (-> (new 'stack-no-clear 'vector) quad) (the-as uint128 0))
|
|
(let ((s0-0 (new-stack-vector0)))
|
|
(set! sv-256 0)
|
|
(set! sv-272 0)
|
|
(while (< sv-272 (the-as int (-> sv-16 elt-count)))
|
|
(when (!= s1-0 sv-272)
|
|
(vector-float*! sv-192 (-> s3-0 sv-272) (-> s3-0 sv-272 w))
|
|
(vector-cross! sv-208 (-> s3-0 sv-272) (-> s3-0 s1-0))
|
|
(vector-normalize! sv-208 (the-as float 1.0))
|
|
(vector-cross! sv-224 sv-208 (-> s3-0 sv-272))
|
|
(vector-normalize! sv-224 (the-as float 1.0))
|
|
(let ((f0-6 (cam-layout-intersect-dist (-> s3-0 s1-0) sv-192 sv-224)))
|
|
(when (!= f0-6 409600000.0)
|
|
(vector+float*! sv-240 sv-192 sv-224 f0-6)
|
|
(set! sv-160 (new-stack-vector0))
|
|
(set! sv-164 0.0)
|
|
(set! sv-168 0)
|
|
(set! sv-176 (new-stack-vector0))
|
|
(set! (-> sv-160 quad) (-> sv-240 quad))
|
|
(set! sv-288 0)
|
|
(while (< sv-288 (the-as int (-> sv-16 elt-count)))
|
|
(when (and (!= sv-288 s1-0) (!= sv-288 sv-272))
|
|
(let ((f30-0 (cam-layout-intersect-dist (-> s3-0 sv-288) sv-160 sv-208)))
|
|
(cond
|
|
((= f30-0 409600000.0)
|
|
)
|
|
((zero? sv-168)
|
|
(vector+float*! sv-160 sv-160 sv-208 f30-0)
|
|
(set! (-> sv-176 quad) (-> s3-0 sv-288 quad))
|
|
(set! sv-164 8192000.0)
|
|
(set! sv-168 1)
|
|
)
|
|
((begin (vector-float*! sv-240 sv-208 f30-0) (>= (vector-dot sv-240 sv-176) 0.0))
|
|
)
|
|
((>= (vector-dot sv-240 (-> s3-0 sv-288)) 0.0)
|
|
(when (< (fabs f30-0) (fabs sv-164))
|
|
(set! sv-164 f30-0)
|
|
(set! sv-168 (+ sv-168 1))
|
|
)
|
|
)
|
|
(else
|
|
(vector+float*! sv-160 sv-160 sv-208 f30-0)
|
|
(set! (-> sv-176 quad) (-> s3-0 sv-288 quad))
|
|
(set! sv-168 (+ sv-168 1))
|
|
(if (< (fabs f30-0) (fabs sv-164))
|
|
(set! sv-164 (- sv-164 f30-0))
|
|
(set! sv-164 0.0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! sv-288 (+ sv-288 1))
|
|
)
|
|
(cond
|
|
((zero? sv-168)
|
|
)
|
|
((= sv-164 0.0)
|
|
)
|
|
(else
|
|
(dotimes (v1-87 (the-as int (-> sv-16 elt-count)))
|
|
(when (and (!= v1-87 s1-0) (!= v1-87 sv-272))
|
|
(if (< 4096.0 (- (vector-dot sv-160 (-> s3-0 v1-87)) (-> s3-0 v1-87 w)))
|
|
(goto cfg-47)
|
|
)
|
|
)
|
|
)
|
|
(vector+float*! sv-240 sv-160 sv-208 sv-164)
|
|
(cond
|
|
((>= *volume-point-current* 999)
|
|
(format 0 "ERROR <GMJ>: camera editing out of volume points~%")
|
|
)
|
|
(else
|
|
(set! (-> *volume-point* data *volume-point-current* quad) (-> sv-160 quad))
|
|
(set! (-> *volume-point* data (+ *volume-point-current* 1) quad) (-> sv-240 quad))
|
|
(set! *volume-point-current* (+ *volume-point-current* 2))
|
|
(+! (-> s2-0 point-count) 2)
|
|
)
|
|
)
|
|
(vector+! s0-0 s0-0 sv-160)
|
|
(vector+! s0-0 s0-0 sv-240)
|
|
(set! sv-256 (+ sv-256 2))
|
|
sv-256
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(label cfg-47)
|
|
(set! sv-272 (+ sv-272 1))
|
|
)
|
|
(when (nonzero? sv-256)
|
|
(vector-float*! s0-0 s0-0 (/ 1.0 (the float sv-256)))
|
|
(cond
|
|
((>= *volume-normal-current* 599)
|
|
(format 0 "ERROR <GMJ>: camera editing out of volume normals~%")
|
|
)
|
|
(else
|
|
(set! (-> *volume-normal* data *volume-normal-current* quad) (-> s0-0 quad))
|
|
(set! (-> *volume-normal* data (+ *volume-normal-current* 1) quad) (-> s3-0 s1-0 quad))
|
|
(set! *volume-normal-current* (+ *volume-normal-current* 2))
|
|
(let ((v1-132 (+ (-> s2-0 normal-count) 2)))
|
|
(set! (-> s2-0 normal-count) v1-132)
|
|
v1-132
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(return #f)
|
|
)
|
|
)
|
|
)
|
|
(+! s4-0 1)
|
|
)
|
|
)
|
|
(the-as symbol #f)
|
|
)
|
|
|
|
;; definition for function cam-layout-entity-volume-info
|
|
(defbehavior cam-layout-entity-volume-info cam-layout ()
|
|
(dotimes (gp-0 (-> self num-volumes))
|
|
(cond
|
|
((and (= gp-0 (-> self cur-volume))
|
|
(= *camera-layout-blink* 'volume)
|
|
(zero? (logand (-> *display* real-actual-frame-counter) 8))
|
|
)
|
|
)
|
|
(else
|
|
(let ((s5-0 (-> *volume-descriptor* pos-vol gp-0)))
|
|
(let ((a0-7 (new 'static 'vector4w :w #x80)))
|
|
(cond
|
|
((= (-> s5-0 volume-type) 'vol)
|
|
(set! (-> a0-7 x) 0)
|
|
(set! (-> a0-7 y) 192)
|
|
(set! (-> a0-7 z) 0)
|
|
0
|
|
)
|
|
((= (-> s5-0 volume-type) 'pvol)
|
|
(set! (-> a0-7 x) 128)
|
|
(set! (-> a0-7 y) 128)
|
|
(set! (-> a0-7 z) 128)
|
|
)
|
|
((= (-> s5-0 volume-type) 'cutoutvol)
|
|
(set! (-> a0-7 x) 192)
|
|
(set! (-> a0-7 y) 0)
|
|
(set! (-> a0-7 z) 0)
|
|
0
|
|
)
|
|
)
|
|
(camera-line-setup a0-7)
|
|
)
|
|
(let ((s4-0 (the-as object (-> s5-0 first-point))))
|
|
(dotimes (s3-0 (/ (-> s5-0 point-count) 2))
|
|
(camera-line-draw (the-as vector s4-0) (&+ (the-as vector s4-0) 16))
|
|
(set! s4-0 (&-> (the-as (inline-array plane-volume) s4-0) 1 first-point))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
|
|
;; definition for function v-slrp!
|
|
;; Used lq/sq
|
|
(defun v-slrp! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float))
|
|
(let ((s2-0 (new-stack-vector0))
|
|
(s1-0 (new-stack-vector0))
|
|
(s0-0 (new-stack-vector0))
|
|
)
|
|
0.0
|
|
0.0
|
|
0.0
|
|
0.0
|
|
(cond
|
|
((< 1.0 arg3)
|
|
(set! arg3 (the-as float 1.0))
|
|
)
|
|
((< arg3 0.0)
|
|
(set! arg3 (the-as float 0.0))
|
|
)
|
|
)
|
|
(vector-normalize-copy! s2-0 arg1 (the-as float 1.0))
|
|
(vector-normalize-copy! s1-0 arg2 (the-as float 1.0))
|
|
(vector-cross! s0-0 s2-0 s1-0)
|
|
(let* ((f30-0 (vector-length s0-0))
|
|
(f28-0 (asin f30-0))
|
|
)
|
|
(vector-float*! arg0 arg1 (/ (sin (* (- 1.0 arg3) f28-0)) f30-0))
|
|
(vector+float*! arg0 arg0 arg2 (/ (sin (* arg3 f28-0)) f30-0))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition of type interp-test-info
|
|
(deftype interp-test-info (structure)
|
|
((from vector :inline :offset-assert 0)
|
|
(to vector :inline :offset-assert 16)
|
|
(origin vector :inline :offset-assert 32)
|
|
(color vector4w :offset-assert 48)
|
|
(axis vector :offset-assert 52)
|
|
(disp string :offset-assert 56)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
)
|
|
|
|
;; definition for method 3 of type interp-test-info
|
|
(defmethod inspect interp-test-info ((obj interp-test-info))
|
|
(format #t "[~8x] ~A~%" obj 'interp-test-info)
|
|
(format #t "~Tfrom: #<vector @ #x~X>~%" (-> obj from))
|
|
(format #t "~Tto: #<vector @ #x~X>~%" (-> obj to))
|
|
(format #t "~Torigin: #<vector @ #x~X>~%" (-> obj origin))
|
|
(format #t "~Tcolor: #<vector4w @ #x~X>~%" (-> obj color))
|
|
(format #t "~Taxis: #<vector @ #x~X>~%" (-> obj axis))
|
|
(format #t "~Tdisp: ~A~%" (-> obj disp))
|
|
obj
|
|
)
|
|
|
|
;; definition for function interp-test
|
|
;; Used lq/sq
|
|
(defun interp-test ((arg0 (function vector vector vector float vector float none)) (arg1 interp-test-info))
|
|
(let ((s3-0 (new-stack-vector0))
|
|
(gp-0 (new-stack-vector0))
|
|
)
|
|
(arg0 s3-0 (-> arg1 from) (-> arg1 to) (the-as float 0.0) (-> arg1 axis) (the-as float 65536.0))
|
|
(vector+! s3-0 s3-0 (-> arg1 origin))
|
|
(dotimes (s2-0 10)
|
|
(set! (-> gp-0 quad) (-> s3-0 quad))
|
|
(arg0 s3-0 (-> arg1 from) (-> arg1 to) (* 0.1 (+ 1.0 (the float s2-0))) (-> arg1 axis) (the-as float 65536.0))
|
|
(vector+! s3-0 s3-0 (-> arg1 origin))
|
|
(camera-line s3-0 gp-0 (-> arg1 color))
|
|
)
|
|
(arg0 gp-0 (-> arg1 from) (-> arg1 to) (-> *CAM_LAYOUT-bank* debug-t) (-> arg1 axis) (the-as float 65536.0))
|
|
(format *stdcon* "~S ~f~%" (-> arg1 disp) (vector-length gp-0))
|
|
(vector+! gp-0 gp-0 (-> arg1 origin))
|
|
(camera-line (-> arg1 origin) gp-0 (-> arg1 color))
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
gp-0
|
|
(-> arg1 color)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function interp-test-deg
|
|
;; Used lq/sq
|
|
(defun interp-test-deg ((arg0 (function vector vector vector vector float none)) (arg1 interp-test-info))
|
|
(let ((s3-0 (new-stack-vector0))
|
|
(gp-0 (new-stack-vector0))
|
|
)
|
|
(arg0 s3-0 (-> arg1 from) (-> arg1 to) (-> arg1 axis) (the-as float 0.0))
|
|
(vector+! s3-0 s3-0 (-> arg1 origin))
|
|
(dotimes (s2-0 10)
|
|
(set! (-> gp-0 quad) (-> s3-0 quad))
|
|
(arg0 s3-0 (-> arg1 from) (-> arg1 to) (-> arg1 axis) (* 182.04445 (* 18.0 (+ 1.0 (the float s2-0)))))
|
|
(vector+! s3-0 s3-0 (-> arg1 origin))
|
|
(camera-line s3-0 gp-0 (-> arg1 color))
|
|
)
|
|
(arg0 gp-0 (-> arg1 from) (-> arg1 to) (-> arg1 axis) (* 182.04445 (* 180.0 (-> *CAM_LAYOUT-bank* debug-t))))
|
|
(format *stdcon* "~S ~f~%" (-> arg1 disp) (vector-length gp-0))
|
|
(vector+! gp-0 gp-0 (-> arg1 origin))
|
|
(camera-line (-> arg1 origin) gp-0 (-> arg1 color))
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
gp-0
|
|
(-> arg1 color)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-entity-info
|
|
;; Used lq/sq
|
|
(defun cam-layout-entity-info ((arg0 entity-actor))
|
|
(if (not arg0)
|
|
(return #f)
|
|
)
|
|
(let ((s5-0 (new-stack-matrix0))
|
|
(s4-0 (new-stack-vector0))
|
|
)
|
|
(when (and (cam-slave-get-vector-with-offset arg0 s4-0 'trans)
|
|
(or (!= *camera-layout-blink* 'camera) (logtest? (-> *display* real-actual-frame-counter) 8))
|
|
)
|
|
(cam-slave-get-rot arg0 s5-0)
|
|
(camera-fov-frame
|
|
s5-0
|
|
s4-0
|
|
(* 0.5 (cam-slave-get-fov arg0))
|
|
(the-as float 0.75)
|
|
(the-as float 1.0)
|
|
(new 'static 'vector4w :z #xff :w #x80)
|
|
)
|
|
)
|
|
)
|
|
(let ((s5-1 (new-stack-vector0)))
|
|
(if (and (cam-slave-get-vector-with-offset arg0 s5-1 'pivot)
|
|
(or (!= *camera-layout-blink* 'pivot) (logtest? (-> *display* real-actual-frame-counter) 8))
|
|
)
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
s5-1
|
|
(new 'static 'vector4w :x #x80 :w #x80)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
(let ((s5-2 (new-stack-vector0)))
|
|
(if (and (cam-slave-get-vector-with-offset arg0 s5-2 'align)
|
|
(or (!= *camera-layout-blink* 'align) (logtest? (-> *display* real-actual-frame-counter) 8))
|
|
)
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
s5-2
|
|
(new 'static 'vector4w :y #x80 :w #x80)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
(let ((s5-3 (new-stack-vector0)))
|
|
(if (and (cam-slave-get-vector-with-offset arg0 s5-3 'interesting)
|
|
(or (!= *camera-layout-blink* 'interesting) (logtest? (-> *display* real-actual-frame-counter) 8))
|
|
)
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
s5-3
|
|
(new 'static 'vector4w :x #x80 :z #x80 :w #x80)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
(let ((s3-1 (new 'stack 'curve))
|
|
(s2-0 (new-stack-vector0))
|
|
(s5-4 (new-stack-vector0))
|
|
(s4-1 (new-stack-vector0))
|
|
)
|
|
(when (and (get-curve-data! arg0 s3-1 'campath 'campath-k (the-as float -1000000000.0))
|
|
(or (!= *camera-layout-blink* 'spline) (logtest? (-> *display* real-actual-frame-counter) 8))
|
|
)
|
|
(cond
|
|
((cam-slave-get-vector-with-offset arg0 s4-1 'pivot)
|
|
(curve-get-pos! s5-4 (the-as float 0.0) s3-1)
|
|
(vector-! s4-1 s4-1 s5-4)
|
|
)
|
|
(else
|
|
(set! (-> s4-1 quad)
|
|
(-> (the-as
|
|
vector
|
|
((method-of-type res-lump get-property-struct)
|
|
arg0
|
|
'spline-offset
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
s4-1
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
quad
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(curve-get-pos! s5-4 (the-as float 0.0) s3-1)
|
|
(vector+! s5-4 s5-4 s4-1)
|
|
(dotimes (s1-1 8)
|
|
(set! (-> s2-0 quad) (-> s5-4 quad))
|
|
(curve-get-pos! s5-4 (* 0.125 (the float (+ s1-1 1))) s3-1)
|
|
(vector+! s5-4 s5-4 s4-1)
|
|
(camera-line s2-0 s5-4 (new 'static 'vector4w :x #xff :y #xff :w #x80))
|
|
)
|
|
(curve-get-pos! s5-4 (-> *CAM_LAYOUT-bank* spline-t) s3-1)
|
|
(vector+! s5-4 s5-4 s4-1)
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
s5-4
|
|
(new 'static 'vector4w :x #xff :y #xff :w #x80)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
(let ((s3-2 (new 'stack 'curve))
|
|
(s2-1 (new-stack-vector0))
|
|
(s5-5 (new-stack-vector0))
|
|
(s4-2 (new-stack-vector0))
|
|
(s1-2 (new 'stack 'curve))
|
|
)
|
|
(when (and (get-curve-data! arg0 s3-2 'intro 'intro-k (the-as float -1000000000.0))
|
|
(or (!= *camera-layout-blink* 'intro) (logtest? (-> *display* real-actual-frame-counter) 8))
|
|
)
|
|
(cond
|
|
((cam-slave-get-vector-with-offset arg0 s4-2 'pivot)
|
|
(curve-get-pos! s5-5 (the-as float 1.0) s3-2)
|
|
(vector-! s4-2 s4-2 s5-5)
|
|
)
|
|
((get-curve-data! arg0 s1-2 'campath 'campath-k (the-as float -1000000000.0))
|
|
(curve-get-pos! s4-2 (the-as float 0.0) s1-2)
|
|
(curve-get-pos! s5-5 (the-as float 1.0) s3-2)
|
|
(vector-! s4-2 s4-2 s5-5)
|
|
)
|
|
((cam-slave-get-vector-with-offset arg0 s4-2 'trans)
|
|
(curve-get-pos! s5-5 (the-as float 1.0) s3-2)
|
|
(vector-! s4-2 s4-2 s5-5)
|
|
)
|
|
)
|
|
(curve-get-pos! s5-5 (the-as float 0.0) s3-2)
|
|
(vector+! s5-5 s5-5 s4-2)
|
|
(dotimes (s1-3 8)
|
|
(set! (-> s2-1 quad) (-> s5-5 quad))
|
|
(curve-get-pos! s5-5 (* 0.125 (the float (+ s1-3 1))) s3-2)
|
|
(vector+! s5-5 s5-5 s4-2)
|
|
(camera-line s2-1 s5-5 (new 'static 'vector4w :z #xff :w #x80))
|
|
)
|
|
(curve-get-pos! s5-5 (-> *CAM_LAYOUT-bank* intro-t) s3-2)
|
|
(vector+! s5-5 s5-5 s4-2)
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
s5-5
|
|
(new 'static 'vector4w :z #xff :w #x80)
|
|
(meters 1.0)
|
|
)
|
|
(curve-get-pos! s5-5 (cam-slave-get-float arg0 'intro-exitValue (the-as float 0.0)) s3-2)
|
|
(vector+! s5-5 s5-5 s4-2)
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
s5-5
|
|
(new 'static 'vector4w :z #xff :w #x80)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
(let ((s2-3 (res-lump-data arg0 'campoints pointer :time (the-as float 1.0)))
|
|
(v1-95 (res-lump-struct arg0 'campoints-offset structure :time (the-as float -1000000000.0)))
|
|
(s4-3 (new 'stack-no-clear 'vector))
|
|
(s3-3 (new 'stack-no-clear 'vector))
|
|
(s5-6 (new 'static 'vector))
|
|
)
|
|
(when (and s2-3 (or (!= *camera-layout-blink* 'index) (logtest? (-> *display* real-actual-frame-counter) 8)))
|
|
(cond
|
|
(v1-95
|
|
(vector+! s4-3 (the-as vector (&+ s2-3 0)) (the-as vector v1-95))
|
|
(vector+! s3-3 (the-as vector (&+ s2-3 16)) (the-as vector v1-95))
|
|
)
|
|
(else
|
|
(set! (-> s4-3 quad) (-> (the-as (pointer uint128) (&+ s2-3 0))))
|
|
(set! (-> s3-3 quad) (-> (the-as (pointer uint128) (&+ s2-3 16))))
|
|
)
|
|
)
|
|
(camera-line s4-3 s3-3 (new 'static 'vector4w :y #x80 :w #x80))
|
|
(vector-lerp-clamp! s5-6 s4-3 s3-3 (-> *CAM_LAYOUT-bank* spline-t))
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
s5-6
|
|
(new 'static 'vector4w :x #xff :y #xff :w #x80)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
(let ((s4-4 (res-lump-data arg0 'focalpull pointer :time (the-as float 1.0)))
|
|
(s5-7 (new 'static 'vector))
|
|
)
|
|
(when (and s4-4 (or (!= *camera-layout-blink* 'focalpull) (logtest? (-> *display* real-actual-frame-counter) 8)))
|
|
(camera-line
|
|
(the-as vector (&+ s4-4 0))
|
|
(the-as vector (&+ s4-4 16))
|
|
(new 'static 'vector4w :y #xff :z #xff :w #x80)
|
|
)
|
|
(vector-lerp-clamp!
|
|
s5-7
|
|
(the-as vector (&+ s4-4 0))
|
|
(the-as vector (&+ s4-4 16))
|
|
(-> *CAM_LAYOUT-bank* spline-t)
|
|
)
|
|
(camera-cross
|
|
(new 'static 'vector :y 1024.0)
|
|
(new 'static 'vector :z 1024.0)
|
|
s5-7
|
|
(new 'static 'vector4w :y #xff :z #xff :w #x80)
|
|
(meters 1.0)
|
|
)
|
|
)
|
|
)
|
|
(let ((s5-8 (new 'stack 'interp-test-info))
|
|
(s4-5 (new-stack-vector0))
|
|
)
|
|
(when (and (cam-slave-get-vector-with-offset arg0 (-> s5-8 origin) 'pivot)
|
|
(cam-slave-get-vector-with-offset arg0 (-> s5-8 to) 'align)
|
|
(cam-slave-get-vector-with-offset arg0 (-> s5-8 from) 'trans)
|
|
)
|
|
(camera-line (-> s5-8 from) (-> s5-8 origin) (new 'static 'vector4w :x #x80 :y #x80 :z #x80 :w #x80))
|
|
(camera-line (-> s5-8 to) (-> s5-8 origin) (new 'static 'vector4w :x #x80 :y #x80 :z #x80 :w #x80))
|
|
(vector-! (-> s5-8 from) (-> s5-8 from) (-> s5-8 origin))
|
|
(vector-! (-> s5-8 to) (-> s5-8 to) (-> s5-8 origin))
|
|
(vector-cross! s4-5 (-> s5-8 from) (-> s5-8 to))
|
|
(vector-normalize! s4-5 (the-as float 8192.0))
|
|
(vector+! s4-5 s4-5 (-> s5-8 origin))
|
|
(camera-line (-> s5-8 origin) s4-5 (new 'static 'vector4w :x #x80 :y #x80 :z #x80 :w #x80))
|
|
(when (not (paused?))
|
|
(+! (-> *CAM_LAYOUT-bank* debug-t) (-> *CAM_LAYOUT-bank* debug-step))
|
|
(if (< 1.0 (-> *CAM_LAYOUT-bank* debug-t))
|
|
(set! (-> *CAM_LAYOUT-bank* debug-t) 0.0)
|
|
)
|
|
)
|
|
(set! (-> s5-8 axis) #f)
|
|
(set! (-> s5-8 disp) "li")
|
|
(set! (-> s5-8 color) (new 'static 'vector4w :x #xff :w #x80))
|
|
(interp-test (the-as (function vector vector vector float vector float none) vector-lerp!) s5-8)
|
|
(set! (-> s5-8 disp) "si")
|
|
(set! (-> s5-8 color) (new 'static 'vector4w :y #xff :w #x80))
|
|
(interp-test (the-as (function vector vector vector float vector float none) v-slrp!) s5-8)
|
|
(set! (-> s5-8 disp) "si2")
|
|
(set! (-> s5-8 color) (new 'static 'vector4w :z #xff :w #x80))
|
|
(interp-test (the-as (function vector vector vector float vector float none) v-slrp2!) s5-8)
|
|
(set! (-> s5-8 disp) "si3")
|
|
(set! (-> s5-8 color) (new 'static 'vector4w :x #xff :z #xff :w #x80))
|
|
(interp-test-deg (the-as (function vector vector vector vector float none) v-slrp3!) s5-8)
|
|
(set! (-> s5-8 axis) (-> *camera* local-down))
|
|
(set! (-> s5-8 disp) "si2d")
|
|
(set! (-> s5-8 color) (new 'static 'vector4w :y #xff :z #xff :w #x80))
|
|
(interp-test (the-as (function vector vector vector float vector float none) v-slrp2!) s5-8)
|
|
(set! (-> s5-8 disp) "si3d")
|
|
(set! (-> s5-8 color) (new 'static 'vector4w :x #xff :y #xff :w #x80))
|
|
(interp-test-deg (the-as (function vector vector vector vector float none) v-slrp3!) s5-8)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function clmf-button-test
|
|
(defun clmf-button-test ()
|
|
(cam-layout-print 16 *camera-layout-message-ypos* "button test")
|
|
(set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 8))
|
|
(set! *camera-read-analog* #f)
|
|
#f
|
|
)
|
|
|
|
;; definition for function clmf-bna
|
|
(defun clmf-bna ()
|
|
(cam-layout-print 16 *camera-layout-message-ypos* "button not applicable")
|
|
(set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 8))
|
|
(set! *camera-read-analog* #f)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-implement
|
|
(defun clmf-implement ()
|
|
(cam-layout-print 16 *camera-layout-message-ypos* "button not implemented yet")
|
|
(set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 8))
|
|
(set! *camera-read-analog* #f)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-input
|
|
;; Used lq/sq
|
|
(defun clmf-input ((arg0 vector) (arg1 vector) (arg2 int))
|
|
(vector-reset! arg0)
|
|
(vector-reset! arg1)
|
|
(cond
|
|
((cpad-hold? arg2 l3)
|
|
(set! (-> arg0 z) (- (-> arg0 z) (analog-input
|
|
(the-as int (-> *cpad-list* cpads arg2 rightx))
|
|
(the-as float 128.0)
|
|
(the-as float 48.0)
|
|
(the-as float 110.0)
|
|
(the-as float 1.0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> arg0 y) (- (-> arg0 y) (analog-input
|
|
(the-as int (-> *cpad-list* cpads arg2 rightx))
|
|
(the-as float 128.0)
|
|
(the-as float 48.0)
|
|
(the-as float 110.0)
|
|
(the-as float 1.0)
|
|
)
|
|
)
|
|
)
|
|
(+! (-> arg0 x) (analog-input
|
|
(the-as int (-> *cpad-list* cpads arg2 righty))
|
|
(the-as float 128.0)
|
|
(the-as float 48.0)
|
|
(the-as float 110.0)
|
|
(the-as float 1.0)
|
|
)
|
|
)
|
|
(set! (-> arg1 x) (- (-> arg1 x) (analog-input
|
|
(the-as int (-> *cpad-list* cpads arg2 leftx))
|
|
(the-as float 128.0)
|
|
(the-as float 48.0)
|
|
(the-as float 110.0)
|
|
(the-as float 1.0)
|
|
)
|
|
)
|
|
)
|
|
(when *camera-read-buttons*
|
|
(if (cpad-hold? arg2 r1)
|
|
(set! (-> arg1 y) (+ 0.5
|
|
(analog-input
|
|
(the-as int (-> *cpad-list* cpads arg2 abutton 9))
|
|
(the-as float 0.0)
|
|
(the-as float 32.0)
|
|
(the-as float 230.0)
|
|
(the-as float 0.5)
|
|
)
|
|
(-> arg1 y)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when *camera-read-buttons*
|
|
(if (cpad-hold? arg2 l1)
|
|
(set! (-> arg1 y) (- (-> arg1 y) (+ 0.5 (analog-input
|
|
(the-as int (-> *cpad-list* cpads arg2 abutton 8))
|
|
(the-as float 0.0)
|
|
(the-as float 32.0)
|
|
(the-as float 230.0)
|
|
(the-as float 0.5)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> arg1 z) (- (-> arg1 z) (analog-input
|
|
(the-as int (-> *cpad-list* cpads arg2 lefty))
|
|
(the-as float 128.0)
|
|
(the-as float 48.0)
|
|
(the-as float 110.0)
|
|
(the-as float 1.0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((s5-1 (new-stack-matrix0)))
|
|
(let ((a2-8 (new-stack-vector0)))
|
|
(set! (-> a2-8 y) -1.0)
|
|
(forward-down-nopitch->inv-matrix s5-1 (-> *math-camera* inv-camera-rot vector 2) a2-8)
|
|
)
|
|
(vector-matrix*! arg1 arg1 s5-1)
|
|
)
|
|
arg1
|
|
)
|
|
|
|
;; definition for function clmf-pos-rot
|
|
;; Used lq/sq
|
|
(defbehavior clmf-pos-rot cam-layout ((arg0 symbol) (arg1 symbol))
|
|
(local-vars (s2-0 structure) (s3-1 structure) (sv-192 matrix))
|
|
(cam-layout-print 16 *camera-layout-message-ypos* "x/z pos: left stick, down: l1, up: r1")
|
|
(set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 8))
|
|
(when (and arg1 (nonzero? arg1))
|
|
(cam-layout-print 16 *camera-layout-message-ypos* "x/y rot: right stick")
|
|
(set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 8))
|
|
(cam-layout-print 16 *camera-layout-message-ypos* "z rot: press left stick & move right")
|
|
(set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 8))
|
|
)
|
|
(let ((s5-0 (new-stack-vector0))
|
|
(s4-0 (new-stack-vector0))
|
|
)
|
|
(set! s3-1
|
|
(cond
|
|
((or (zero? arg0) (not arg0))
|
|
#f
|
|
)
|
|
(else
|
|
(if (not (res-lump-struct (-> self cam-entity) arg0 structure :time (the-as float -1000000000.0)))
|
|
(add-data!
|
|
(-> self cam-entity)
|
|
(new 'static 'res-tag :name arg0 :key-frame -1000000000.0 :elt-count #x1 :inlined? #x1 :elt-type vector)
|
|
(the-as pointer (new 'static 'vector))
|
|
)
|
|
)
|
|
(set! s3-1 (res-lump-struct (-> self cam-entity) arg0 structure :time (the-as float -1000000000.0)))
|
|
(when (and (not s3-1) (logtest? (-> *display* real-actual-frame-counter) 8))
|
|
(clear *temp-string*)
|
|
(format *temp-string* "ERROR <GMJ>: can't add ~A" 'vector)
|
|
(cam-layout-print 120 100 *temp-string*)
|
|
)
|
|
s3-1
|
|
)
|
|
)
|
|
)
|
|
(set! s2-0
|
|
(cond
|
|
((or (zero? arg1) (not arg1))
|
|
#f
|
|
)
|
|
(else
|
|
(if (not (res-lump-struct (-> self cam-entity) arg1 structure :time (the-as float -1000000000.0)))
|
|
(add-data!
|
|
(-> self cam-entity)
|
|
(new 'static 'res-tag :name arg1 :key-frame -1000000000.0 :elt-count #x1 :inlined? #x1 :elt-type quaternion)
|
|
(the-as pointer (quaternion-identity! (new 'static 'quaternion)))
|
|
)
|
|
)
|
|
(set! s2-0 (res-lump-struct (-> self cam-entity) arg1 structure :time (the-as float -1000000000.0)))
|
|
(when (and (not s2-0) (logtest? (-> *display* real-actual-frame-counter) 8))
|
|
(clear *temp-string*)
|
|
(format *temp-string* "ERROR <GMJ>: can't add ~A" 'quaternion)
|
|
(cam-layout-print 120 100 *temp-string*)
|
|
)
|
|
s2-0
|
|
)
|
|
)
|
|
)
|
|
(let ((s1-1 (new 'stack-no-clear 'matrix)))
|
|
(set! sv-192 (new 'stack-no-clear 'matrix))
|
|
(let ((s0-1 (new 'stack-no-clear 'vector)))
|
|
(if (not s3-1)
|
|
(return #f)
|
|
)
|
|
(clmf-input s5-0 s4-0 0)
|
|
(vector+float*! (the-as vector s3-1) (the-as vector s3-1) s4-0 (the-as float 409.6))
|
|
(cond
|
|
((not arg1)
|
|
(the-as quaternion #f)
|
|
)
|
|
((zero? arg1)
|
|
(the-as quaternion #f)
|
|
)
|
|
(else
|
|
(cam-slave-get-rot (the-as entity-actor (-> self cam-entity)) sv-192)
|
|
(vector-float*! s5-0 s5-0 100.0)
|
|
(matrix-rotate-x! s1-1 (- (-> s5-0 x)))
|
|
(matrix*! sv-192 s1-1 sv-192)
|
|
(matrix-rotate-y! s1-1 (-> s5-0 y))
|
|
(matrix*! sv-192 sv-192 s1-1)
|
|
(matrix-rotate-z! s1-1 (- (-> s5-0 z)))
|
|
(matrix*! sv-192 s1-1 sv-192)
|
|
(matrix->quaternion (the-as quaternion s0-1) sv-192)
|
|
(quaternion-inverse! (the-as quaternion s2-0) (the-as quaternion (-> self cam-entity connect)))
|
|
(quaternion*! (the-as quaternion s2-0) (the-as quaternion s0-1) (the-as quaternion s2-0))
|
|
(quaternion-normalize! (the-as quaternion s2-0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! *camera-read-analog* #f)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-next-volume
|
|
(defbehavior clmf-next-volume cam-layout ((arg0 int))
|
|
(if (zero? (-> self num-volumes))
|
|
(return #f)
|
|
)
|
|
(set! (-> self cur-volume) (mod (+ arg0 (-> self cur-volume)) (-> self num-volumes)))
|
|
(while (< (-> self cur-volume) 0)
|
|
(+! (-> self cur-volume) (-> self num-volumes))
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-next-vol-dpad
|
|
(defun clmf-next-vol-dpad ()
|
|
(local-vars (a0-1 int))
|
|
(cam-layout-print 16 *camera-layout-message-ypos* "dpad selects volume")
|
|
(set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 8))
|
|
(cond
|
|
((cpad-pressed? 0 down)
|
|
(set! a0-1 1)
|
|
)
|
|
((cpad-pressed? 0 right)
|
|
(set! a0-1 1)
|
|
)
|
|
((cpad-pressed? 0 up)
|
|
(set! a0-1 -1)
|
|
)
|
|
((cpad-pressed? 0 left)
|
|
(set! a0-1 -1)
|
|
)
|
|
(else
|
|
(set! a0-1 0)
|
|
)
|
|
)
|
|
(clmf-next-volume a0-1)
|
|
(set! *camera-read-analog* #f)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-to-edit-cam
|
|
(defun clmf-to-edit-cam ()
|
|
(clmf-next-volume 0)
|
|
(set! *clm* *clm-edit*)
|
|
#t
|
|
)
|
|
|
|
;; definition for symbol *last-cur-entity*, type int
|
|
(define *last-cur-entity* -1)
|
|
|
|
;; definition for function clmf-next-entity
|
|
(defbehavior clmf-next-entity cam-layout ((arg0 int))
|
|
(let ((v1-0 (/ arg0 8)))
|
|
(when (zero? (-> self num-entities))
|
|
(set! (-> self cam-entity) #f)
|
|
(return #f)
|
|
)
|
|
(if (= (- v1-0) (-> self num-entities))
|
|
(set! v1-0 -1)
|
|
)
|
|
(if (= v1-0 (-> self num-entities))
|
|
(set! v1-0 1)
|
|
)
|
|
(set! (-> self cur-entity) (mod (+ v1-0 (-> self cur-entity)) (-> self num-entities)))
|
|
)
|
|
(while (< (-> self cur-entity) 0)
|
|
(+! (-> self cur-entity) (-> self num-entities))
|
|
)
|
|
(set! *last-cur-entity* (-> self cur-entity))
|
|
(let ((v1-8 (-> self cur-entity))
|
|
(a0-13 (-> *camera-engine* alive-list next0))
|
|
)
|
|
*camera-engine*
|
|
(let ((a1-3 (-> a0-13 next0)))
|
|
(while (!= a0-13 (-> *camera-engine* alive-list-end))
|
|
(let ((a0-14 (-> (the-as connection a0-13) param1)))
|
|
(cond
|
|
((zero? v1-8)
|
|
(set! (-> self cam-entity) (the-as entity-camera a0-14))
|
|
(set! *volume-descriptor-current* 0)
|
|
(set! *volume-point-current* 0)
|
|
(set! *volume-normal-current* 0)
|
|
(set! (-> self num-volumes) 0)
|
|
(cam-layout-entity-volume-info-create (-> self cam-entity) 'vol)
|
|
(set! (-> self first-pvol) (-> self num-volumes))
|
|
(cam-layout-entity-volume-info-create (-> self cam-entity) 'pvol)
|
|
(set! (-> self first-cutoutvol) (-> self num-volumes))
|
|
(cam-layout-entity-volume-info-create (-> self cam-entity) 'cutoutvol)
|
|
(set! (-> *CAM_LAYOUT-bank* intro-step) (cam-slave-get-intro-step (-> self cam-entity)))
|
|
(return #f)
|
|
)
|
|
(else
|
|
(+! v1-8 -1)
|
|
)
|
|
)
|
|
)
|
|
(set! a0-13 a1-3)
|
|
*camera-engine*
|
|
(set! a1-3 (-> a1-3 next0))
|
|
)
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-to-vol-attr
|
|
(defbehavior clmf-to-vol-attr cam-layout ()
|
|
(set! (-> self res-key) (the float (-> self cur-volume)))
|
|
(set! *clm* *clm-vol-attr*)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-to-spline-attr
|
|
(defun clmf-to-spline-attr ()
|
|
(set! *clm* *clm-spline-attr*)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-to-intro-attr
|
|
(defun clmf-to-intro-attr ()
|
|
(set! *clm* *clm-intro-attr*)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-to-index-attr
|
|
(defun clmf-to-index-attr ()
|
|
(set! *clm* *clm-index-attr*)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-to-focalpull-attr
|
|
(defun clmf-to-focalpull-attr ()
|
|
(set! *clm* *clm-focalpull-attr*)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-to-edit
|
|
(defbehavior clmf-to-edit cam-layout ()
|
|
(set! (-> self res-key) -1000000000.0)
|
|
(set! *clm* *clm-edit*)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-to-select
|
|
(defun clmf-to-select ()
|
|
(set! *camera-layout-blink* #f)
|
|
(set! *clm* *clm-select*)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-look-through
|
|
;; Used lq/sq
|
|
(defbehavior clmf-look-through cam-layout ()
|
|
(set! (-> *camera-other-fov* data) (cam-slave-get-fov (-> self cam-entity)))
|
|
(cam-slave-get-vector-with-offset (the-as entity-actor (-> self cam-entity)) *camera-other-trans* 'trans)
|
|
(set! (-> *camera-other-root* quad) (-> *camera-other-trans* quad))
|
|
(cam-slave-get-rot (the-as entity-actor (-> self cam-entity)) *camera-other-matrix*)
|
|
(set! *camera-look-through-other* 10)
|
|
(set! *camera-read-analog* #f)
|
|
#f
|
|
)
|
|
|
|
;; definition for function fov->maya
|
|
;; INFO: Return type mismatch number vs float.
|
|
(defun fov->maya ((arg0 float))
|
|
(the-as float (if (= arg0 0.0)
|
|
0.0
|
|
(/ 12.700255 (tan (* 0.5 arg0)))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-cam-rot
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-cam-rot ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s3-0 (-> arg2 quat))
|
|
(s5-0 (res-lump-struct arg2 'rot-offset vector :time (the-as float -1000000000.0)))
|
|
)
|
|
(if arg0
|
|
(format #t "setup rot ~f ~f ~f ~f~%" (-> s3-0 x) (-> s3-0 y) (-> s3-0 z) (-> s3-0 w))
|
|
)
|
|
(the-as string (when s5-0
|
|
(if arg0
|
|
(format #t "rot offset ~f ~f ~f ~f~%" (-> s5-0 x) (-> s5-0 y) (-> s5-0 z) (-> s5-0 w))
|
|
)
|
|
(format
|
|
arg1
|
|
" tag rot-offset ~f ~f ~f ~f // vector (quaternion)~%"
|
|
(-> s5-0 x)
|
|
(-> s5-0 y)
|
|
(-> s5-0 z)
|
|
(-> s5-0 w)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-cam-trans
|
|
;; INFO: Return type mismatch object vs string.
|
|
;; Used lq/sq
|
|
(defun cam-layout-save-cam-trans ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s1-0 (-> arg2 trans))
|
|
(s5-0 (method-of-type res-lump get-property-struct))
|
|
(s2-0 arg2)
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'trans '-offset)
|
|
(let ((s5-1 (the-as vector (s5-0
|
|
s2-0
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
#f
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((s2-1 (res-lump-struct arg2 'translation_info vector :time (the-as float -1000000000.0)))
|
|
(s3-1 (new-stack-vector0))
|
|
)
|
|
(if arg0
|
|
(format #t "setup trans ~M ~M ~M (maya)~%" (-> s1-0 x) (-> s1-0 y) (-> s1-0 z))
|
|
)
|
|
(set! (-> s3-1 quad) (-> s1-0 quad))
|
|
(when (the-as structure s5-1)
|
|
(if arg0
|
|
(format #t "offset ~M ~M ~M (added)~%" (-> s5-1 x) (-> s5-1 y) (-> s5-1 z))
|
|
)
|
|
(vector+! s3-1 s3-1 s5-1)
|
|
)
|
|
(when s2-1
|
|
(if arg0
|
|
(format #t "level-trans ~M ~M ~M (subtracted)~%" (-> s2-1 x) (-> s2-1 y) (-> s2-1 z))
|
|
)
|
|
(vector-! s3-1 s3-1 s2-1)
|
|
)
|
|
(set! s2-1 (the-as vector (or s5-1 s2-1)))
|
|
(set! arg0 (and (the-as symbol s2-1) arg0))
|
|
(if arg0
|
|
(format #t "final trans ~M ~M ~M (maya)~%" (-> s3-1 x) (-> s3-1 y) (-> s3-1 z))
|
|
)
|
|
)
|
|
(the-as string (if s5-1
|
|
(format
|
|
arg1
|
|
" tag trans-offset METERS(~M) METERS(~M) METERS(~M) 1.0 // vector~%"
|
|
(-> s5-1 x)
|
|
(-> s5-1 y)
|
|
(-> s5-1 z)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-pivot
|
|
;; INFO: Return type mismatch object vs string.
|
|
;; Used lq/sq
|
|
(defun cam-layout-save-pivot ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s2-0 (res-lump-struct arg2 'pivot vector :time (the-as float -1000000000.0)))
|
|
(s3-0 (method-of-type res-lump get-property-struct))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'pivot '-offset)
|
|
(let ((s5-1 (the-as vector (s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
#f
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(s3-1 (new-stack-vector0))
|
|
)
|
|
(the-as string (when s2-0
|
|
(if s5-1
|
|
(vector+! s3-1 s2-0 s5-1)
|
|
(set! (-> s3-1 quad) (-> s2-0 quad))
|
|
)
|
|
(if arg0
|
|
(format #t "setup pivot ~M ~M ~M~%" (-> s2-0 x) (-> s2-0 y) (-> s2-0 z))
|
|
)
|
|
(when s5-1
|
|
(when arg0
|
|
(format #t "offset ~M ~M ~M~%" (-> s5-1 x) (-> s5-1 y) (-> s5-1 z))
|
|
(format #t "final pivot ~M ~M ~M~%" (-> s3-1 x) (-> s3-1 y) (-> s3-1 z))
|
|
)
|
|
(format
|
|
arg1
|
|
" tag pivot-offset METERS(~M) METERS(~M) METERS(~M) 1.0 // vector~%"
|
|
(-> s5-1 x)
|
|
(-> s5-1 y)
|
|
(-> s5-1 z)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-align
|
|
;; INFO: Return type mismatch object vs string.
|
|
;; Used lq/sq
|
|
(defun cam-layout-save-align ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s2-0 (res-lump-struct arg2 'align vector :time (the-as float -1000000000.0)))
|
|
(s3-0 (method-of-type res-lump get-property-struct))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'align '-offset)
|
|
(let ((s5-1 (the-as vector (s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
#f
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(s3-1 (new-stack-vector0))
|
|
)
|
|
(the-as string (when s2-0
|
|
(if s5-1
|
|
(vector+! s3-1 s2-0 s5-1)
|
|
(set! (-> s3-1 quad) (-> s2-0 quad))
|
|
)
|
|
(if arg0
|
|
(format #t "setup align ~M ~M ~M~%" (-> s2-0 x) (-> s2-0 y) (-> s2-0 z))
|
|
)
|
|
(when s5-1
|
|
(when arg0
|
|
(format #t "offset ~M ~M ~M~%" (-> s5-1 x) (-> s5-1 y) (-> s5-1 z))
|
|
(format #t "final align ~M ~M ~M~%" (-> s3-1 x) (-> s3-1 y) (-> s3-1 z))
|
|
)
|
|
(format
|
|
arg1
|
|
" tag align-offset METERS(~M) METERS(~M) METERS(~M) 1.0 // vector~%"
|
|
(-> s5-1 x)
|
|
(-> s5-1 y)
|
|
(-> s5-1 z)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-interesting
|
|
;; INFO: Return type mismatch object vs string.
|
|
;; Used lq/sq
|
|
(defun cam-layout-save-interesting ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s2-0 (res-lump-struct arg2 'interesting vector :time (the-as float -1000000000.0)))
|
|
(s3-0 (method-of-type res-lump get-property-struct))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'interesting '-offset)
|
|
(let ((s5-1 (the-as vector (s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
#f
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(s3-1 (new-stack-vector0))
|
|
)
|
|
(the-as string (when s2-0
|
|
(if s5-1
|
|
(vector+! s3-1 s2-0 s5-1)
|
|
(set! (-> s3-1 quad) (-> s2-0 quad))
|
|
)
|
|
(if arg0
|
|
(format #t "setup interesting ~M ~M ~M~%" (-> s2-0 x) (-> s2-0 y) (-> s2-0 z))
|
|
)
|
|
(when s5-1
|
|
(when arg0
|
|
(format #t "offset ~M ~M ~M~%" (-> s5-1 x) (-> s5-1 y) (-> s5-1 z))
|
|
(format #t "final interesting ~M ~M ~M~%" (-> s3-1 x) (-> s3-1 y) (-> s3-1 z))
|
|
)
|
|
(format
|
|
arg1
|
|
" tag interesting-offset METERS(~M) METERS(~M) METERS(~M) 1.0 // vector~%"
|
|
(-> s5-1 x)
|
|
(-> s5-1 y)
|
|
(-> s5-1 z)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-fov
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-fov ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'fov
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'fov '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((= f30-0 0.0)
|
|
(if arg0
|
|
(format #t "setup fov deg 0.0 (defaults to 64.0)~%")
|
|
)
|
|
(set! f30-0 11650.845)
|
|
)
|
|
(arg0
|
|
(format #t "setup fov deg ~R (~f in maya)~%" f30-0 (fov->maya f30-0))
|
|
)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~R~%" f28-0)
|
|
(format #t "final ~R (~f in maya) ~%" (+ f30-0 f28-0) (fov->maya (+ f30-0 f28-0)))
|
|
)
|
|
(format arg1 " tag fov-offset DEG(~R) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-focalpull
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-focalpull ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'focalPull
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'focalPull '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup focalPull deg ~R (~f in maya)~%" f30-0 (fov->maya f30-0))
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~R~%" f28-0)
|
|
(format #t "final ~R (~f in maya) ~%" (+ f30-0 f28-0) (fov->maya (+ f30-0 f28-0)))
|
|
)
|
|
(format arg1 " tag focalPull-offset DEG(~R) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-flags
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-flags ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s4-0 (res-lump-value arg2 'flags uint128 :time (the-as float -1000000000.0)))
|
|
(s5-0 (method-of-type res-lump get-property-value))
|
|
(s1-0 arg2)
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'flags '-on)
|
|
(let ((s5-1 (s5-0
|
|
s1-0
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s1-1 (method-of-type res-lump get-property-value))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'flags '-off)
|
|
(let ((s3-1 (s1-1
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(when arg0
|
|
(format #t "setup flags ")
|
|
(cam-slave-options->string (the-as cam-slave-options s4-0) #t)
|
|
(format #t "~%")
|
|
(format #t "forced on ")
|
|
(cam-slave-options->string (the-as cam-slave-options s5-1) #t)
|
|
(format #t "~%")
|
|
(format #t "forced off ")
|
|
(cam-slave-options->string (the-as cam-slave-options s3-1) #t)
|
|
(format #t "~%")
|
|
(let ((s4-1 (logclear (logior s4-0 s5-1) s3-1)))
|
|
(format #t "final ")
|
|
(cam-slave-options->string (the-as cam-slave-options s4-1) #t)
|
|
)
|
|
(format #t "~%")
|
|
)
|
|
(format arg1 " tag flags-on 0x~X // int32~%" s5-1)
|
|
(the-as string (format arg1 " tag flags-off 0x~X // int32~%" s3-1))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-focalpull-flags
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-focalpull-flags ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s4-0 (res-lump-value arg2 'focalpull-flags uint128 :time (the-as float -1000000000.0)))
|
|
(s5-0 (method-of-type res-lump get-property-value))
|
|
(s1-0 arg2)
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'focalpull-flags '-on)
|
|
(let ((s5-1 (s5-0
|
|
s1-0
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s1-1 (method-of-type res-lump get-property-value))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'focalpull-flags '-off)
|
|
(let ((s3-1
|
|
(s1-1
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(when arg0
|
|
(format #t "setup focalpull-flags ")
|
|
(cam-index-options->string (the-as cam-index-options s4-0) #t)
|
|
(format #t "~%")
|
|
(format #t "forced on ")
|
|
(cam-index-options->string (the-as cam-index-options s5-1) #t)
|
|
(format #t "~%")
|
|
(format #t "forced off ")
|
|
(cam-index-options->string (the-as cam-index-options s3-1) #t)
|
|
(format #t "~%")
|
|
(let ((s4-1 (logclear (logior s4-0 s5-1) s3-1)))
|
|
(format #t "final ")
|
|
(cam-index-options->string (the-as cam-index-options s4-1) #t)
|
|
)
|
|
(format #t "~%")
|
|
)
|
|
(format arg1 " tag focalpull-flags-on 0x~X // int32~%" s5-1)
|
|
(the-as
|
|
string
|
|
(format arg1 " tag focalpull-flags-off 0x~X // int32~%" s3-1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-campoints-flags
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-campoints-flags ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s4-0 (res-lump-value arg2 'campoints-flags uint128 :time (the-as float -1000000000.0)))
|
|
(s5-0 (method-of-type res-lump get-property-value))
|
|
(s1-0 arg2)
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'campoints-flags '-on)
|
|
(let ((s5-1 (s5-0
|
|
s1-0
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s1-1 (method-of-type res-lump get-property-value))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'campoints-flags '-off)
|
|
(let ((s3-1
|
|
(s1-1
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(when arg0
|
|
(format #t "setup campoints-flags ")
|
|
(cam-index-options->string (the-as cam-index-options s4-0) #t)
|
|
(format #t "~%")
|
|
(format #t "forced on ")
|
|
(cam-index-options->string (the-as cam-index-options s5-1) #t)
|
|
(format #t "~%")
|
|
(format #t "forced off ")
|
|
(cam-index-options->string (the-as cam-index-options s3-1) #t)
|
|
(format #t "~%")
|
|
(let ((s4-1 (logclear (logior s4-0 s5-1) s3-1)))
|
|
(format #t "final ")
|
|
(cam-index-options->string (the-as cam-index-options s4-1) #t)
|
|
)
|
|
(format #t "~%")
|
|
)
|
|
(format arg1 " tag campoints-flags-on 0x~X // int32~%" s5-1)
|
|
(the-as
|
|
string
|
|
(format arg1 " tag campoints-flags-off 0x~X // int32~%" s3-1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-introsplinetime
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-introsplinetime ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'intro-time
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'intro-time '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((= f30-0 0.0)
|
|
(if arg0
|
|
(format #t "setup intro-time 0.0 (defaults to 1 sec)~%")
|
|
)
|
|
(set! f30-0 1.0)
|
|
)
|
|
(arg0
|
|
(format #t "setup intro-time ~f~%" f30-0)
|
|
)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~f~%" f28-0)
|
|
(format #t "final ~f~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag intro-time-offset SECONDS(~f) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-introsplineexitval
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-introsplineexitval ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'intro-exitValue
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'intro-exitValue '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(when arg0
|
|
(if (= f30-0 0.0)
|
|
(format #t "setup intro-exitValue 0.0 (defaults to 0.5)~%")
|
|
(format #t "setup intro-exitValue ~f~%" f30-0)
|
|
)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~f~%" f28-0)
|
|
(format #t "final ~f~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag intro-exitValue-offset ~f // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-interptime
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-interptime ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'interpTime
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'interpTime '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup interpTime ~f~%" f30-0)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~f~%" f28-0)
|
|
(format #t "final ~f~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag interpTime-offset SECONDS(~f) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-splineoffset
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-splineoffset ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(the-as
|
|
string
|
|
(when (and (not (res-lump-struct arg2 'pivot structure :time (the-as float -1000000000.0)))
|
|
(res-lump-struct arg2 'spline-offset structure :time (the-as float -1000000000.0))
|
|
)
|
|
(let ((s4-1 (res-lump-struct arg2 'spline-offset vector :time (the-as float -1000000000.0))))
|
|
(when s4-1
|
|
(if arg0
|
|
(format #t "spline offset ~M ~M ~M~%" (-> s4-1 x) (-> s4-1 y) (-> s4-1 z))
|
|
)
|
|
(format
|
|
arg1
|
|
" tag spline-offset METERS(~M) METERS(~M) METERS(~M) 1.0 // vector~%"
|
|
(-> s4-1 x)
|
|
(-> s4-1 y)
|
|
(-> s4-1 z)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-spline-follow-dist-offset
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-spline-follow-dist-offset ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(the-as string (when (and (not (res-lump-struct arg2 'pivot structure :time (the-as float -1000000000.0)))
|
|
((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'spline-follow-dist-offset
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float #f)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'spline-follow-dist-offset
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(when (the int f30-0)
|
|
(if arg0
|
|
(format #t "spline follow dist offset ~M~%" f30-0)
|
|
)
|
|
(format arg1 " tag spline-follow-dist-offset METERS(~M)~%" f30-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-campointsoffset
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-campointsoffset ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((s5-0 (res-lump-struct arg2 'campoints-offset vector :time (the-as float -1000000000.0))))
|
|
(the-as string (when s5-0
|
|
(if arg0
|
|
(format #t "index offset ~M ~M ~M~%" (-> s5-0 x) (-> s5-0 y) (-> s5-0 z))
|
|
)
|
|
(format
|
|
arg1
|
|
" tag campoints-offset METERS(~M) METERS(~M) METERS(~M) 1.0 // vector~%"
|
|
(-> s5-0 x)
|
|
(-> s5-0 y)
|
|
(-> s5-0 z)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-tiltAdjust
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-tiltAdjust ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'tiltAdjust
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'tiltAdjust '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup tiltAdjust deg ~R~%" f30-0)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~R~%" f28-0)
|
|
(format #t "final ~R~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag tiltAdjust-offset DEG(~R) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-stringMinLength
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-stringMinLength ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'stringMinLength
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'stringMinLength '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup stringMinLength ~M~%" f30-0)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~M~%" f28-0)
|
|
(format #t "final ~M~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag stringMinLength-offset METERS(~M) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-stringMaxLength
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-stringMaxLength ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'stringMaxLength
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'stringMaxLength '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup stringMaxLength ~M~%" f30-0)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~M~%" f28-0)
|
|
(format #t "final ~M~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag stringMaxLength-offset METERS(~M) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-stringMinHeight
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-stringMinHeight ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'stringMinHeight
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'stringMinHeight '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup stringMinHeight ~M~%" f30-0)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~M~%" f28-0)
|
|
(format #t "final ~M~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag stringMinHeight-offset METERS(~M) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-stringMaxHeight
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-stringMaxHeight ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'stringMaxHeight
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'stringMaxHeight '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup stringMaxHeight ~M~%" f30-0)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~M~%" f28-0)
|
|
(format #t "final ~M~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag stringMaxHeight-offset METERS(~M) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-stringCliffHeight
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-stringCliffHeight ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'stringCliffHeight
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'stringCliffHeight '-offset)
|
|
(let ((f28-0
|
|
(s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup stringCliffHeight ~M~%" f30-0)
|
|
)
|
|
(the-as
|
|
string
|
|
(when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~M~%" f28-0)
|
|
(format #t "final ~M~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag stringCliffHeight-offset METERS(~M) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-save-maxAngle
|
|
;; INFO: Return type mismatch object vs string.
|
|
(defun cam-layout-save-maxAngle ((arg0 symbol) (arg1 string) (arg2 entity-actor))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
arg2
|
|
'maxAngle
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(s3-0 (method-of-type res-lump get-property-value-float))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" 'maxAngle '-offset)
|
|
(let ((f28-0 (s3-0
|
|
arg2
|
|
(string->symbol *res-key-string*)
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(if arg0
|
|
(format #t "setup maxAngle ~R~%" f30-0)
|
|
)
|
|
(the-as string (when (!= f28-0 0.0)
|
|
(when arg0
|
|
(format #t "offset ~R~%" f28-0)
|
|
(format #t "final ~R~%" (+ f30-0 f28-0))
|
|
)
|
|
(format arg1 " tag maxAngle-offset DEG(~R) // float~%" f28-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function clmf-save-single
|
|
(defbehavior clmf-save-single cam-layout ((arg0 entity-camera) (arg1 symbol) (arg2 symbol))
|
|
(clear *temp-string*)
|
|
(if arg2
|
|
(format
|
|
*temp-string*
|
|
"dd_next/caminfo/~s.cam"
|
|
(res-lump-struct arg0 'name structure :time (the-as float -1000000000.0))
|
|
)
|
|
(format *temp-string* "dd_next/caminfo/garbage")
|
|
)
|
|
(let ((s4-2 (new 'stack 'file-stream *temp-string* 'write)))
|
|
(if arg1
|
|
(format
|
|
#t
|
|
"---------camera '~S'------------~%"
|
|
(res-lump-struct arg0 'name structure :time (the-as float -1000000000.0))
|
|
)
|
|
)
|
|
(format s4-2 "#include /next/config_data/standard.m2d~%")
|
|
(format s4-2 "camera ~s {~%" (res-lump-struct arg0 'name structure :time (the-as float -1000000000.0)))
|
|
(cam-layout-save-cam-rot arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-cam-trans arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-pivot arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-align arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-interesting arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-fov arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-focalpull arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-flags arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-introsplinetime arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-introsplineexitval arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-interptime arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-splineoffset arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-spline-follow-dist-offset arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-campointsoffset arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-tiltAdjust arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-stringMinLength arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-stringMaxLength arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-stringMinHeight arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-stringMaxHeight arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-stringCliffHeight arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-maxAngle arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-campoints-flags arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(cam-layout-save-focalpull-flags arg1 (the-as string s4-2) (the-as entity-actor arg0))
|
|
(format s4-2 "}~%")
|
|
(file-stream-close s4-2)
|
|
)
|
|
)
|
|
|
|
;; definition for function clmf-save-one
|
|
(defbehavior clmf-save-one cam-layout ((arg0 symbol))
|
|
(let ((s5-1 (logtest? (the-as int arg0) 8))
|
|
(gp-1 (logtest? (the-as int arg0) 16))
|
|
)
|
|
(if s5-1
|
|
(format #t "~%~%~%=================================~%")
|
|
)
|
|
(clmf-save-single (-> self cam-entity) s5-1 gp-1)
|
|
(if s5-1
|
|
(format #t "===============================~%~%~%~%")
|
|
)
|
|
(if gp-1
|
|
(format
|
|
#t
|
|
"'~S' save completed~%"
|
|
(res-lump-struct (-> self cam-entity) 'name structure :time (the-as float -1000000000.0))
|
|
)
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-save-all
|
|
(defbehavior clmf-save-all cam-layout ((arg0 symbol))
|
|
(let ((s5-1 (logtest? (the-as int arg0) 8))
|
|
(gp-1 (logtest? (the-as int arg0) 16))
|
|
)
|
|
(if s5-1
|
|
(format #t "~%~%~%=================================~%")
|
|
)
|
|
(let ((v1-5 (-> *camera-engine* alive-list next0)))
|
|
*camera-engine*
|
|
(let ((s4-0 (-> v1-5 next0)))
|
|
(while (!= v1-5 (-> *camera-engine* alive-list-end))
|
|
(let ((a0-4 (-> (the-as connection v1-5) param1)))
|
|
(clmf-save-single (the-as entity-camera a0-4) s5-1 gp-1)
|
|
)
|
|
(set! v1-5 s4-0)
|
|
*camera-engine*
|
|
(set! s4-0 (-> s4-0 next0))
|
|
)
|
|
)
|
|
)
|
|
(if s5-1
|
|
(format #t "===============================~%~%~%~%")
|
|
)
|
|
(if gp-1
|
|
(format #t "camera save all completed~%")
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition of type clmf-cam-flag-toggle-info
|
|
(deftype clmf-cam-flag-toggle-info (structure)
|
|
((key float :offset-assert 0)
|
|
(force-on int32 :offset-assert 4)
|
|
(force-off int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|
|
;; definition for method 3 of type clmf-cam-flag-toggle-info
|
|
(defmethod inspect clmf-cam-flag-toggle-info ((obj clmf-cam-flag-toggle-info))
|
|
(format #t "[~8x] ~A~%" obj 'clmf-cam-flag-toggle-info)
|
|
(format #t "~Tkey: ~f~%" (-> obj key))
|
|
(format #t "~Tforce-on: ~D~%" (-> obj force-on))
|
|
(format #t "~Tforce-off: ~D~%" (-> obj force-off))
|
|
obj
|
|
)
|
|
|
|
;; definition for function clmf-cam-flag-toggle
|
|
(defbehavior clmf-cam-flag-toggle cam-layout ((arg0 int) (arg1 int))
|
|
(let ((s4-0 (/ arg0 8))
|
|
(gp-0 (new 'stack 'clmf-cam-flag-toggle-info))
|
|
)
|
|
(set! (-> gp-0 key) (-> self res-key))
|
|
(cond
|
|
((and (= arg1 'vol-flags) (>= (-> self res-key) (the float (-> self first-cutoutvol))))
|
|
(set! (-> gp-0 key) (- (-> gp-0 key) (the float (-> self first-cutoutvol))))
|
|
(set! arg1 (the-as int 'cutoutvol-flags))
|
|
)
|
|
((and (= arg1 'vol-flags) (>= (-> self res-key) (the float (-> self first-pvol))))
|
|
(set! (-> gp-0 key) (- (-> gp-0 key) (the float (-> self first-pvol))))
|
|
(set! arg1 (the-as int 'pvol-flags))
|
|
)
|
|
)
|
|
(let ((s3-0 (method-of-type res-lump get-property-value))
|
|
(s2-0 (-> self cam-entity))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" (the-as object arg1) '-on)
|
|
(set! (-> gp-0 force-on) (the-as int (s3-0
|
|
s2-0
|
|
(string->symbol *res-key-string*)
|
|
'exact
|
|
(-> gp-0 key)
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((s3-1 (method-of-type res-lump get-property-value))
|
|
(s2-1 (-> self cam-entity))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" (the-as object arg1) '-off)
|
|
(set! (-> gp-0 force-off) (the-as int (s3-1
|
|
s2-1
|
|
(string->symbol *res-key-string*)
|
|
'exact
|
|
(-> gp-0 key)
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((logtest? (-> gp-0 force-off) s4-0)
|
|
(logclear! (-> gp-0 force-off) s4-0)
|
|
(logior! (-> gp-0 force-on) s4-0)
|
|
(let* ((s4-1 (-> self cam-entity))
|
|
(s3-2 (method-of-object s4-1 add-32bit-data!))
|
|
(s2-2 (logior (shl #x10000 32) (shr (shl (the-as int int32) 32) 32)))
|
|
(s1-2 (shl (the-as int (-> gp-0 key)) 32))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" (the-as object arg1) '-off)
|
|
(s3-2
|
|
s4-1
|
|
(the-as
|
|
res-tag
|
|
(make-u128 s2-2 (logior s1-2 (shr (shl (the-as int (string->symbol *res-key-string*)) 32) 32)))
|
|
)
|
|
(-> gp-0 force-off)
|
|
)
|
|
)
|
|
(let* ((s4-2 (-> self cam-entity))
|
|
(s3-3 (method-of-object s4-2 add-32bit-data!))
|
|
(s2-3 (logior (shl #x10000 32) (shr (shl (the-as int int32) 32) 32)))
|
|
(s1-3 (shl (the-as int (-> gp-0 key)) 32))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" (the-as object arg1) '-on)
|
|
(s3-3
|
|
s4-2
|
|
(the-as
|
|
res-tag
|
|
(make-u128 s2-3 (logior s1-3 (shr (shl (the-as int (string->symbol *res-key-string*)) 32) 32)))
|
|
)
|
|
(-> gp-0 force-on)
|
|
)
|
|
)
|
|
)
|
|
((logtest? (-> gp-0 force-on) s4-0)
|
|
(logclear! (-> gp-0 force-on) s4-0)
|
|
(let* ((s4-3 (-> self cam-entity))
|
|
(s3-4 (method-of-object s4-3 add-32bit-data!))
|
|
(s2-4 (logior (shl #x10000 32) (shr (shl (the-as int int32) 32) 32)))
|
|
(s1-4 (shl (the-as int (-> gp-0 key)) 32))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" (the-as object arg1) '-on)
|
|
(s3-4
|
|
s4-3
|
|
(the-as
|
|
res-tag
|
|
(make-u128 s2-4 (logior s1-4 (shr (shl (the-as int (string->symbol *res-key-string*)) 32) 32)))
|
|
)
|
|
(-> gp-0 force-on)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(logior! (-> gp-0 force-off) s4-0)
|
|
(let* ((s4-4 (-> self cam-entity))
|
|
(s3-5 (method-of-object s4-4 add-32bit-data!))
|
|
(s2-5 (logior (shl #x10000 32) (shr (shl (the-as int int32) 32) 32)))
|
|
(s1-5 (shl (the-as int (-> gp-0 key)) 32))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" (the-as object arg1) '-off)
|
|
(s3-5
|
|
s4-4
|
|
(the-as
|
|
res-tag
|
|
(make-u128 s2-5 (logior s1-5 (shr (shl (the-as int (string->symbol *res-key-string*)) 32) 32)))
|
|
)
|
|
(-> gp-0 force-off)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-flag
|
|
(defbehavior clmf-cam-flag cam-layout ((arg0 string) (arg1 uint) (arg2 uint))
|
|
(let ((s5-0 (/ (the-as int arg1) 8))
|
|
(f30-0 (-> self res-key))
|
|
)
|
|
(cond
|
|
((and (= arg2 'vol-flags) (>= (-> self res-key) (the float (-> self first-cutoutvol))))
|
|
(set! f30-0 (- f30-0 (the float (-> self first-cutoutvol))))
|
|
(set! arg2 (the-as uint 'cutoutvol-flags))
|
|
)
|
|
((and (= arg2 'vol-flags) (>= (-> self res-key) (the float (-> self first-pvol))))
|
|
(set! f30-0 (- f30-0 (the float (-> self first-pvol))))
|
|
(set! arg2 (the-as uint 'pvol-flags))
|
|
)
|
|
)
|
|
(let ((s3-0 (method-of-type res-lump get-property-value))
|
|
(s2-0 (-> self cam-entity))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" (the-as object arg2) '-off)
|
|
(cond
|
|
((logtest? (s3-0
|
|
s2-0
|
|
(string->symbol *res-key-string*)
|
|
'exact
|
|
f30-0
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
s5-0
|
|
)
|
|
(format arg0 ": off")
|
|
)
|
|
((let ((s3-1 (method-of-type res-lump get-property-value))
|
|
(s2-1 (-> self cam-entity))
|
|
)
|
|
(format (clear *res-key-string*) "~S~S" (the-as object arg2) '-on)
|
|
(logtest? (s3-1
|
|
s2-1
|
|
(string->symbol *res-key-string*)
|
|
'exact
|
|
f30-0
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
s5-0
|
|
)
|
|
)
|
|
(format arg0 ": on")
|
|
)
|
|
((zero? (logand ((method-of-type res-lump get-property-value)
|
|
(-> self cam-entity)
|
|
(the-as symbol arg2)
|
|
'exact
|
|
f30-0
|
|
(the-as uint128 0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
s5-0
|
|
)
|
|
)
|
|
(format arg0 ": off(maya)")
|
|
)
|
|
(else
|
|
(format arg0 ": on(maya)")
|
|
)
|
|
)
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-float-adjust
|
|
(defbehavior clmf-cam-float-adjust cam-layout ((arg0 symbol) (arg1 (pointer float)))
|
|
(cam-layout-print 16 *camera-layout-message-ypos* "left stick adjusts value")
|
|
(set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 8))
|
|
(let ((f30-0 ((method-of-type res-lump get-property-value-float)
|
|
(-> self cam-entity)
|
|
arg0
|
|
'interp
|
|
(the-as float -1000000000.0)
|
|
(the-as float 0.0)
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
(f0-0 (-> arg1 0))
|
|
)
|
|
(if (= f0-0 0.0)
|
|
(set! f0-0 1.0)
|
|
)
|
|
(let ((f0-2
|
|
(+ f30-0
|
|
(analog-input
|
|
(the-as int (-> *cpad-list* cpads 0 leftx))
|
|
(the-as float 128.0)
|
|
(the-as float 48.0)
|
|
(the-as float 110.0)
|
|
f0-0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(add-32bit-data!
|
|
(-> self cam-entity)
|
|
(new 'static 'res-tag :name arg0 :key-frame -1000000000.0 :elt-count #x1 :elt-type float)
|
|
f0-2
|
|
)
|
|
)
|
|
)
|
|
(set! *camera-read-analog* #f)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-meters
|
|
(defbehavior clmf-cam-meters cam-layout ((arg0 meters) (arg1 symbol))
|
|
(let ((f0-0 (cam-slave-get-float (-> self cam-entity) arg1 (the-as float 0.0))))
|
|
(format arg0 ": ~M" f0-0)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-fov
|
|
(defbehavior clmf-cam-fov cam-layout ((arg0 degrees) (arg1 symbol))
|
|
(format arg0 ": ~R" (cam-slave-get-fov (-> self cam-entity)))
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-deg
|
|
(defbehavior clmf-cam-deg cam-layout ((arg0 degrees) (arg1 symbol))
|
|
(format arg0 ": ~R" (cam-slave-get-float (-> self cam-entity) arg1 (the-as float 0.0)))
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-intro-time
|
|
(defbehavior clmf-cam-intro-time cam-layout ((arg0 float) (arg1 symbol))
|
|
(let ((f30-0 (cam-slave-get-intro-step (-> self cam-entity))))
|
|
(format arg0 ": ~f" (/ 0.016666668 f30-0))
|
|
(set! (-> *CAM_LAYOUT-bank* intro-step) f30-0)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-interp-time
|
|
(defbehavior clmf-cam-interp-time cam-layout ((arg0 float) (arg1 symbol))
|
|
(format arg0 ": ~f" (cam-slave-get-interp-time (-> self cam-entity)))
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-float
|
|
(defbehavior clmf-cam-float cam-layout ((arg0 float) (arg1 symbol))
|
|
(format arg0 ": ~f" (cam-slave-get-float (-> self cam-entity) arg1 (the-as float 0.0)))
|
|
#t
|
|
)
|
|
|
|
;; definition for function clmf-cam-string
|
|
;; Used lq/sq
|
|
(defbehavior clmf-cam-string cam-layout ((arg0 string) (arg1 symbol))
|
|
(local-vars (sv-16 res-tag))
|
|
(format arg0 ":")
|
|
(set! sv-16 (new 'static 'res-tag))
|
|
(let ((s5-1 (res-lump-data (-> self cam-entity) arg1 pointer :tag-ptr (& sv-16) :time (the-as float -1000000000.0)))
|
|
)
|
|
(when s5-1
|
|
(dotimes (s4-0 (the-as int (-> sv-16 elt-count)))
|
|
(format arg0 " ~S" (-> (the-as (pointer uint32) (&+ s5-1 (* s4-0 4)))))
|
|
)
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for symbol *clm-focalpull-attr*, type clm
|
|
(define *clm-focalpull-attr*
|
|
(new 'static 'clm
|
|
:title "---focalpull attributes--"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " ok"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func '*clm-edit*)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "adjust"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :func #f)
|
|
)
|
|
(new 'static 'clm-list
|
|
:tracker #f
|
|
:items (new 'static 'boxed-array :type clm-list-item
|
|
(new 'static 'clm-list-item
|
|
:description "radial "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 16
|
|
:val-parm1-basic 'focalpull-flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 16
|
|
:parm1-basic 'focalpull-flags
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "spherical "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 8
|
|
:val-parm1-basic 'focalpull-flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action (new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 8
|
|
:parm1-basic 'focalpull-flags
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-index-attr*, type clm
|
|
(define *clm-index-attr*
|
|
(new 'static 'clm
|
|
:title "---index attributes--"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " ok"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func '*clm-edit*)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "adjust"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :func #f)
|
|
)
|
|
(new 'static 'clm-list
|
|
:tracker #f
|
|
:items (new 'static 'boxed-array :type clm-list-item
|
|
(new 'static 'clm-list-item
|
|
:description "radial "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 16
|
|
:val-parm1-basic 'campoints-flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 16
|
|
:parm1-basic 'campoints-flags
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "spherical "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 8
|
|
:val-parm1-basic 'campoints-flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action (new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 8
|
|
:parm1-basic 'campoints-flags
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-intro-attr*, type clm
|
|
(define *clm-intro-attr*
|
|
(new 'static 'clm
|
|
:title "---intro attributes--"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " ok"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func '*clm-edit*)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "adjust"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :func #f)
|
|
)
|
|
(new 'static 'clm-list
|
|
:tracker #f
|
|
:items (new 'static 'boxed-array :type clm-list-item
|
|
(new 'static 'clm-list-item
|
|
:description "time "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-intro-time
|
|
:val-parm0-basic 'intro-time
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'intro-time-offset
|
|
:parm1-basic (new 'static 'bfloat :data 0.01)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "exitValue"
|
|
:track-val #f
|
|
:val-func 'clmf-cam-float
|
|
:val-parm0-basic 'intro-exitValue
|
|
:actions (new 'static 'boxed-array :type clm-item-action (new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'intro-exitValue-offset
|
|
:parm1-basic (new 'static 'bfloat :data 0.001)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-spline-attr*, type clm
|
|
(define *clm-spline-attr*
|
|
(new 'static 'clm
|
|
:title "---spline attributes--"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " ok"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func '*clm-edit*)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "adjust"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :func #f)
|
|
)
|
|
(new 'static 'clm-list
|
|
:tracker #f
|
|
:items (new 'static 'boxed-array :type clm-list-item
|
|
(new 'static 'clm-list-item
|
|
:description "followDist"
|
|
:track-val #f
|
|
:val-func 'clmf-cam-meters
|
|
:val-parm0-basic 'spline-follow-dist
|
|
:actions (new 'static 'boxed-array :type clm-item-action (new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'spline-follow-dist-offset
|
|
:parm1-basic (new 'static 'bfloat :data 409.6)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-vol-attr*, type clm
|
|
(define *clm-vol-attr*
|
|
(new 'static 'clm
|
|
:title "---volume attributes--"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " ok"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func '*clm-edit*)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "adjust"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :func #f)
|
|
)
|
|
(new 'static 'clm-list
|
|
:tracker #f
|
|
:items (new 'static 'boxed-array :type clm-list-item
|
|
(new 'static 'clm-list-item
|
|
:description "airSwitch"
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 8
|
|
:val-parm1-basic 'vol-flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action (new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 8
|
|
:parm1-basic 'vol-flags
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-cam-attr*, type clm
|
|
(define *clm-cam-attr*
|
|
(new 'static 'clm
|
|
:title "---camera attributes--"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " ok"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func '*clm-edit*)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "adjust"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :func #f)
|
|
)
|
|
(new 'static 'clm-list
|
|
:tracker #f
|
|
:items (new 'static 'boxed-array :type clm-list-item
|
|
(new 'static 'clm-list-item
|
|
:description "drag "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 #x400
|
|
:val-parm1-basic 'flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 #x400
|
|
:parm1-basic 'flags
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "fov "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-fov
|
|
:val-parm0-basic 'fov
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'fov-offset
|
|
:parm1-basic (new 'static 'bfloat :data 91.022224)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "focalPull "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-deg
|
|
:val-parm0-basic 'focalPull
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'focalPull-offset
|
|
:parm1-basic (new 'static 'bfloat :data 91.022224)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "interpTime "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-interp-time
|
|
:val-parm0-basic 'interpTime
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'interpTime-offset
|
|
:parm1-basic (new 'static 'bfloat :data 0.01)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "sameSide "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 16
|
|
:val-parm1-basic 'flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 16
|
|
:parm1-basic 'flags
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "spherical "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 32
|
|
:val-parm1-basic 'flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 32
|
|
:parm1-basic 'flags
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "MinLength "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-meters
|
|
:val-parm0-basic 'stringMinLength
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'stringMinLength-offset
|
|
:parm1-basic (new 'static 'bfloat :data 409.6)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "MaxLength "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-meters
|
|
:val-parm0-basic 'stringMaxLength
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'stringMaxLength-offset
|
|
:parm1-basic (new 'static 'bfloat :data 409.6)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "MinHeight "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-meters
|
|
:val-parm0-basic 'stringMinHeight
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'stringMinHeight-offset
|
|
:parm1-basic (new 'static 'bfloat :data 409.6)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "MaxHeight "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-meters
|
|
:val-parm0-basic 'stringMaxHeight
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'stringMaxHeight-offset
|
|
:parm1-basic (new 'static 'bfloat :data 409.6)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "cliffHeight"
|
|
:track-val #f
|
|
:val-func 'clmf-cam-meters
|
|
:val-parm0-basic 'stringCliffHeight
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'stringCliffHeight-offset
|
|
:parm1-basic (new 'static 'bfloat :data 409.6)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "alternates "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-string
|
|
:val-parm0-basic 'alternates
|
|
:actions (new 'static 'boxed-array :type clm-item-action)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "maxAngle "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-deg
|
|
:val-parm0-basic 'maxAngle
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'maxAngle-offset
|
|
:parm1-basic (new 'static 'bfloat :data 91.022224)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "shrinkAngle"
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 #x4000
|
|
:val-parm1-basic 'flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 #x4000
|
|
:parm1-basic 'flags
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "noRotate "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 #x40000
|
|
:val-parm1-basic 'flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 #x40000
|
|
:parm1-basic 'flags
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "tiltAdjust "
|
|
:track-val #f
|
|
:val-func 'clmf-cam-deg
|
|
:val-parm0-basic 'tiltAdjust
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'tiltAdjust-offset
|
|
:parm1-basic (new 'static 'bfloat :data 91.022224)
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "stickyAngle"
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 #x80000
|
|
:val-parm1-basic 'flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 #x80000
|
|
:parm1-basic 'flags
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "airExit"
|
|
:track-val #f
|
|
:val-func 'clmf-cam-flag
|
|
:val-parm0 #x100000
|
|
:val-parm1-basic 'flags
|
|
:actions (new 'static 'boxed-array :type clm-item-action (new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x1
|
|
:func 'clmf-cam-flag-toggle
|
|
:parm0 #x100000
|
|
:parm1-basic 'flags
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-cam-lookthrough*, type clm
|
|
(define *clm-cam-lookthrough*
|
|
(new 'static 'clm
|
|
:title "---cam-lookthrough---"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " "
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :options #x4 :func 'clmf-look-through)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " ok"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func 'clmf-to-edit)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "pos/rot"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action
|
|
:button #x4000
|
|
:options #x8
|
|
:func 'clmf-pos-rot
|
|
:parm0-basic 'trans-offset
|
|
:parm1-basic 'rot-offset
|
|
)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " adjust"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :func #f)
|
|
)
|
|
(new 'static 'clm-list
|
|
:tracker #f
|
|
:items (new 'static 'boxed-array :type clm-list-item
|
|
(new 'static 'clm-list-item
|
|
:description "fov"
|
|
:track-val #f
|
|
:val-func 'clmf-cam-fov
|
|
:val-parm0-basic 'fov
|
|
:actions (new 'static 'boxed-array :type clm-item-action (new 'static 'clm-item-action
|
|
:button #x4000
|
|
:func 'clmf-cam-float-adjust
|
|
:parm0-basic 'fov-offset
|
|
:parm1-basic (new 'static 'bfloat :data 91.022224)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-edit*, type clm
|
|
(define *clm-edit*
|
|
(new 'static 'clm
|
|
:title "---edit---"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " ok"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func 'clmf-to-select)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "attributes"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :options #x1 :func #f)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " edit part"
|
|
:button-symbol 'circle
|
|
:action (new 'static 'clm-item-action :button #x2000 :options #x1 :func #f)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "scale/next"
|
|
:button-symbol 'r2
|
|
:action (new 'static 'clm-item-action :button #x200 :func #f)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " pos/rot"
|
|
:button-symbol 'l2
|
|
:action (new 'static 'clm-item-action :button #x100 :func #f)
|
|
)
|
|
(new 'static 'clm-list
|
|
:tracker '*camera-layout-blink*
|
|
:items (new 'static 'boxed-array :type clm-list-item
|
|
(new 'static 'clm-list-item
|
|
:description "camera "
|
|
:track-val 'camera
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :options #x1 :func '*clm-cam-attr*)
|
|
(new 'static 'clm-item-action :button #x2000 :func '*clm-cam-lookthrough*)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action
|
|
:button #x100
|
|
:func 'clmf-pos-rot
|
|
:parm0-basic 'trans-offset
|
|
:parm1-basic 'rot-offset
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "volume "
|
|
:track-val 'volume
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :options #x1 :func 'clmf-to-vol-attr)
|
|
(new 'static 'clm-item-action :button #x2000 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-next-vol-dpad)
|
|
(new 'static 'clm-item-action :button #x100 :func 'clmf-implement)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "align "
|
|
:track-val 'align
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action :button #x2000 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action :button #x100 :func 'clmf-pos-rot :parm0-basic 'align-offset :parm1-basic #f)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "pivot "
|
|
:track-val 'pivot
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action :button #x2000 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action :button #x100 :func 'clmf-pos-rot :parm0-basic 'pivot-offset :parm1-basic #f)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "interesting"
|
|
:track-val 'interesting
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action :button #x2000 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-bna)
|
|
(new 'static 'clm-item-action
|
|
:button #x100
|
|
:func 'clmf-pos-rot
|
|
:parm0-basic 'interesting-offset
|
|
:parm1-basic #f
|
|
)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "spline "
|
|
:track-val 'spline
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :func 'clmf-to-spline-attr)
|
|
(new 'static 'clm-item-action :button #x2000 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x100 :func 'clmf-pos-rot :parm0-basic 'spline-offset :parm1-basic #f)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "intro "
|
|
:track-val 'intro
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :options #x1 :func 'clmf-to-intro-attr)
|
|
(new 'static 'clm-item-action :button #x2000 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x100 :func 'clmf-implement)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "index "
|
|
:track-val 'index
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :options #x1 :func 'clmf-to-index-attr)
|
|
(new 'static 'clm-item-action :button #x2000 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x100 :func 'clmf-pos-rot :parm0-basic 'campoints-offset)
|
|
)
|
|
)
|
|
(new 'static 'clm-list-item
|
|
:description "focalpull"
|
|
:track-val 'focalpull
|
|
:val-func #f
|
|
:actions (new 'static 'boxed-array :type clm-item-action
|
|
(new 'static 'clm-item-action :button #x4000 :options #x1 :func 'clmf-to-focalpull-attr)
|
|
(new 'static 'clm-item-action :button #x2000 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x200 :func 'clmf-implement)
|
|
(new 'static 'clm-item-action :button #x100 :func 'clmf-implement)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-save-all*, type clm
|
|
(define *clm-save-all*
|
|
(new 'static 'clm
|
|
:title "---save all?---"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " save all"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :options #x1 :func 'clmf-save-all :parm0 16)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "print all"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func 'clmf-save-all :parm0 8)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " done"
|
|
:button-symbol 'triangle
|
|
:action (new 'static 'clm-item-action :button #x1000 :options #x1 :func 'clmf-to-select)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-save-one*, type clm
|
|
(define *clm-save-one*
|
|
(new 'static 'clm
|
|
:title "---single save?---"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " single save"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :options #x1 :func 'clmf-save-one :parm0 16)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "single print"
|
|
:button-symbol 'square
|
|
:action (new 'static 'clm-item-action :button #x8000 :options #x1 :func 'clmf-save-one :parm0 8)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " done"
|
|
:button-symbol 'triangle
|
|
:action (new 'static 'clm-item-action :button #x1000 :options #x1 :func 'clmf-to-select)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm-select*, type clm
|
|
(define *clm-select*
|
|
(new 'static 'clm
|
|
:title "---camera---"
|
|
:items (new 'static 'boxed-array :type clm-basic
|
|
(new 'static 'clm-item
|
|
:description " edit"
|
|
:button-symbol 'x
|
|
:action (new 'static 'clm-item-action :button #x4000 :options #x3 :func 'clmf-to-edit-cam)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description "save one"
|
|
:button-symbol 'triangle
|
|
:action (new 'static 'clm-item-action :button #x1000 :options #x3 :func '*clm-save-one*)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " next"
|
|
:button-symbol 'down
|
|
:action (new 'static 'clm-item-action :button #x40 :options #x3 :func 'clmf-next-entity :parm0 8)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " prev"
|
|
:button-symbol 'up
|
|
:action (new 'static 'clm-item-action :button #x10 :options #x3 :func 'clmf-next-entity :parm0 -8)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " next 5"
|
|
:button-symbol 'right
|
|
:action (new 'static 'clm-item-action :button #x20 :options #x3 :func 'clmf-next-entity :parm0 40)
|
|
)
|
|
(new 'static 'clm-item
|
|
:description " prev 5"
|
|
:button-symbol 'left
|
|
:action (new 'static 'clm-item-action :button #x80 :options #x3 :func 'clmf-next-entity :parm0 -40)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *clm*, type clm
|
|
(define *clm* *clm-select*)
|
|
|
|
;; definition for function cam-layout-do-action
|
|
(defbehavior cam-layout-do-action cam-layout ((arg0 clm-item-action))
|
|
(let ((s5-0 (-> arg0 func value)))
|
|
(cond
|
|
((not s5-0)
|
|
#f
|
|
)
|
|
((zero? s5-0)
|
|
#f
|
|
)
|
|
((and (not (-> self cam-entity)) (logtest? (-> arg0 options) 2))
|
|
#f
|
|
)
|
|
((and (logtest? (-> arg0 options) 8) (logtest? (-> *cpad-list* cpads 0 button0-abs 0) (-> arg0 button)))
|
|
#f
|
|
)
|
|
((and (zero? (logand (-> arg0 options) 12))
|
|
(logtest? (-> arg0 options) 1)
|
|
(zero? (logand (-> *cpad-list* cpads 0 button0-rel 0) (-> arg0 button)))
|
|
)
|
|
#f
|
|
)
|
|
((and (zero? (logand (-> arg0 options) 13))
|
|
(zero? (logand (-> *cpad-list* cpads 0 button0-abs 0) (-> arg0 button)))
|
|
)
|
|
#f
|
|
)
|
|
((type-type? (-> (the-as basic s5-0) type) clm)
|
|
(set! *clm* (the-as clm s5-0))
|
|
#t
|
|
)
|
|
((type-type? (-> (the-as basic s5-0) type) function)
|
|
((the-as (function object symbol symbol) s5-0) (-> arg0 parm0) (the-as symbol (-> arg0 parm1-basic)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-function-call
|
|
(defbehavior cam-layout-function-call cam-layout ((arg0 symbol) (arg1 string) (arg2 int) (arg3 basic))
|
|
(let ((gp-0 (-> arg0 value)))
|
|
(cond
|
|
((not gp-0)
|
|
)
|
|
((zero? gp-0)
|
|
)
|
|
((type-type? (-> (the-as basic gp-0) type) function)
|
|
((the-as (function string int basic none) gp-0) arg1 arg2 arg3)
|
|
)
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
|
|
;; definition for function cam-layout-do-menu
|
|
;; INFO: Return type mismatch symbol vs none.
|
|
(defbehavior cam-layout-do-menu cam-layout ((arg0 clm))
|
|
(set! *camera-layout-message-ypos* 30)
|
|
(+! (-> *CAM_LAYOUT-bank* spline-t) (-> *CAM_LAYOUT-bank* spline-step))
|
|
(if (< 1.01 (-> *CAM_LAYOUT-bank* spline-t))
|
|
(set! (-> *CAM_LAYOUT-bank* spline-t) -0.09)
|
|
)
|
|
(+! (-> *CAM_LAYOUT-bank* intro-t) (-> *CAM_LAYOUT-bank* intro-step))
|
|
(if (< 1.01 (-> *CAM_LAYOUT-bank* intro-t))
|
|
(set! (-> *CAM_LAYOUT-bank* intro-t) -0.09)
|
|
)
|
|
(let ((s5-0 30))
|
|
(let ((s4-0 (cam-state-from-entity (-> self cam-entity))))
|
|
(set! *camera-read-analog* #t)
|
|
(let ((s3-0 (-> self cam-entity)))
|
|
(clear *temp-string*)
|
|
(if s3-0
|
|
(format *temp-string* "\"~S\"~%" (res-lump-struct s3-0 'name structure :time (the-as float -1000000000.0)))
|
|
)
|
|
)
|
|
(if (not s4-0)
|
|
(format *temp-string* "no cameras in this level")
|
|
(format *temp-string* "~S" (-> s4-0 name))
|
|
)
|
|
)
|
|
(cam-layout-print 320 s5-0 *temp-string*)
|
|
(let ((s5-1 (+ s5-0 16)))
|
|
(clear *temp-string*)
|
|
(format *temp-string* "~S~%" (-> arg0 title))
|
|
(cam-layout-print 320 s5-1 *temp-string*)
|
|
(let ((s4-1 (+ s5-1 8)))
|
|
(dotimes (s5-2 (-> arg0 items length))
|
|
(cond
|
|
((type-type? (-> arg0 items s5-2 type) clm-list)
|
|
(clear *temp-string*)
|
|
(format *temp-string* "------------")
|
|
(cam-layout-print 320 s4-1 *temp-string*)
|
|
(let ((s4-2 (+ s4-1 8)))
|
|
(let ((s3-1 (the-as clm-list (-> arg0 items s5-2))))
|
|
(dotimes (s2-1 (-> s3-1 items length))
|
|
(clear *temp-string*)
|
|
(format
|
|
*temp-string*
|
|
"~S~S"
|
|
(if (= s2-1 (-> s3-1 cur-list-item))
|
|
"> "
|
|
" "
|
|
)
|
|
(-> s3-1 items s2-1 description)
|
|
)
|
|
(cam-layout-function-call
|
|
(-> s3-1 items s2-1 val-func)
|
|
*temp-string*
|
|
(-> s3-1 items s2-1 val-parm0)
|
|
(-> s3-1 items s2-1 val-parm1-basic)
|
|
)
|
|
(cam-layout-print 320 s4-2 *temp-string*)
|
|
(+! s4-2 8)
|
|
)
|
|
)
|
|
(clear *temp-string*)
|
|
(format *temp-string* "------------")
|
|
(cam-layout-print 320 s4-2 *temp-string*)
|
|
(set! s4-1 (+ s4-2 8))
|
|
)
|
|
)
|
|
((and (not (-> self cam-entity)) (logtest? (-> (the-as clm-item (-> arg0 items s5-2)) action options) 2))
|
|
)
|
|
((logtest? (-> (the-as clm-item (-> arg0 items s5-2)) action options) 4)
|
|
)
|
|
(else
|
|
(let ((s3-2 (-> arg0 items s5-2)))
|
|
(clear *temp-string*)
|
|
(format
|
|
*temp-string*
|
|
"~S: ~A~%"
|
|
(-> (the-as clm-item s3-2) description)
|
|
(if (logtest? (-> (the-as clm-item (-> arg0 items s5-2)) action options) 8)
|
|
'default
|
|
(-> (the-as clm-item s3-2) button-symbol)
|
|
)
|
|
)
|
|
)
|
|
(cam-layout-print 320 s4-1 *temp-string*)
|
|
(+! s4-1 8)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(if (= *master-mode* 'menu)
|
|
(goto cfg-65)
|
|
)
|
|
(dotimes (s5-3 (-> arg0 items length))
|
|
(cond
|
|
((type-type? (-> arg0 items s5-3 type) clm-list)
|
|
(let ((s4-3 (-> arg0 items s5-3))
|
|
(s3-3 0)
|
|
)
|
|
(if (-> (the-as clm-list s4-3) tracker)
|
|
(set! (-> (the-as clm-list s4-3) tracker value)
|
|
(-> (the-as clm-list s4-3) items (-> (the-as clm-list s4-3) cur-list-item) track-val)
|
|
)
|
|
)
|
|
(dotimes (s2-2 (-> (the-as clm-list s4-3) items (-> (the-as clm-list s4-3) cur-list-item) actions length))
|
|
(if (cam-layout-do-action
|
|
(-> (the-as clm-list s4-3) items (-> (the-as clm-list s4-3) cur-list-item) actions s2-2)
|
|
)
|
|
(goto cfg-65)
|
|
)
|
|
)
|
|
(cond
|
|
((cpad-pressed? 0 down)
|
|
(set! s3-3 1)
|
|
)
|
|
((cpad-pressed? 0 right)
|
|
(set! s3-3 1)
|
|
)
|
|
((cpad-pressed? 0 up)
|
|
(set! s3-3 -1)
|
|
)
|
|
((cpad-pressed? 0 left)
|
|
(set! s3-3 -1)
|
|
)
|
|
)
|
|
(when (nonzero? s3-3)
|
|
(set! (-> (the-as clm-list s4-3) cur-list-item)
|
|
(mod (+ (-> (the-as clm-list s4-3) cur-list-item) s3-3) (-> (the-as clm-list s4-3) items length))
|
|
)
|
|
(while (< (-> (the-as clm-list s4-3) cur-list-item) 0)
|
|
(+! (-> (the-as clm-list s4-3) cur-list-item) (-> (the-as clm-list s4-3) items length))
|
|
)
|
|
(goto cfg-65)
|
|
)
|
|
)
|
|
)
|
|
((cam-layout-do-action (-> (the-as clm-item (-> arg0 items s5-3)) action))
|
|
(goto cfg-65)
|
|
)
|
|
)
|
|
)
|
|
(label cfg-65)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate cam-layout-active (cam-layout)
|
|
:code (behavior ()
|
|
(loop
|
|
(cam-layout-entity-info (the-as entity-actor (-> self cam-entity)))
|
|
(cam-layout-entity-volume-info)
|
|
(cam-layout-do-menu *clm*)
|
|
(suspend)
|
|
)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-layout-init
|
|
;; INFO: Return type mismatch object vs none.
|
|
(defbehavior cam-layout-init cam-layout ()
|
|
(set! (-> self res-key) -1000000000.0)
|
|
(set! (-> self num-entities) 0)
|
|
(let ((v1-2 (-> *camera-engine* alive-list next0)))
|
|
*camera-engine*
|
|
(let ((a0-2 (-> v1-2 next0)))
|
|
(while (!= v1-2 (-> *camera-engine* alive-list-end))
|
|
(-> (the-as connection v1-2) param1)
|
|
(+! (-> self num-entities) 1)
|
|
(set! v1-2 a0-2)
|
|
*camera-engine*
|
|
(set! a0-2 (-> a0-2 next0))
|
|
)
|
|
)
|
|
)
|
|
(set! (-> self cur-entity) *last-cur-entity*)
|
|
(clmf-next-entity 0)
|
|
(set! *clm* *clm-select*)
|
|
(go cam-layout-active)
|
|
(none)
|
|
)
|
|
|
|
;; definition for function cam-layout-stop
|
|
(defun cam-layout-stop ()
|
|
(set! *cam-layout* #f)
|
|
(kill-by-name 'cam-layout *active-pool*)
|
|
)
|
|
|
|
;; definition for function cam-layout-start
|
|
;; INFO: Return type mismatch symbol vs none.
|
|
(defun cam-layout-start ()
|
|
(let ((a0-1 (new 'global 'file-stream "dd_next/caminfo/garbage" 'read)))
|
|
(file-stream-close a0-1)
|
|
)
|
|
(cond
|
|
((not *cam-layout*)
|
|
(let ((v1-4 (process-spawn-function cam-layout cam-layout-init :from *camera-dead-pool*)))
|
|
(cond
|
|
(v1-4
|
|
(logclear! (-> v1-4 0 mask) (process-mask pause menu))
|
|
(set! *cam-layout* #t)
|
|
(set! *camera-layout-blink* #f)
|
|
)
|
|
(else
|
|
(format 0 "ERROR <GMJ>: no process available to start cam editing mode~%")
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(format 0 "ERROR <GMJ>: cam editing mode already started~%")
|
|
)
|
|
)
|
|
*cam-layout*
|
|
(none)
|
|
)
|
|
|
|
;; definition for function cam-layout-restart
|
|
(defun cam-layout-restart ()
|
|
(cam-layout-stop)
|
|
(cam-layout-start)
|
|
(none)
|
|
)
|
|
|
|
)
|